pxmli.c File Reference

---

Detailed Description

This file parses the XML file, and if needed, loads the data. See the DTD and introduction for complete information on the XML tag structure. Parsing the XML file requires libxml2 library.

Functions
void	loadXML (const char *filename, Parratt *par)
	Parses the XML file.
void	parseOutput (xmlDocPtr doc, xmlNodePtr nod, Parratt *par)
	Parses the XML <output> tag.
void	parseFit (xmlDocPtr doc, xmlNodePtr nod, Parratt *par)
	Parses the XML <fit> tag.
void	parseModel (xmlDocPtr doc, xmlNodePtr nod, Parratt *par)
	Parses the XML <model> tag.
void	parseLayer (xmlDocPtr doc, xmlNodePtr lay, Parratt *par, int type)
	Parses the XML <layer> tag.
void	parseRepeat (xmlDocPtr doc, xmlNodePtr rep, Parratt *par)
	Parses the XML <repeat> tag.

---

Function Documentation

void loadXML	(	const char *	filename,
		Parratt *	par
	)

This function validates and parses the XML file. The root layer here is <parratt>, and the only expected children are <fit>, <output>, and <model>

{
    xmlValidCtxtPtr  ctx; 
    xmlDocPtr        doc;
    xmlNodePtr       nod;
    xmlChar         *buf;

    /*====================================================
     *  Bunch of error checking and document validation
     */
    doc = xmlParseFile(filename);
    if (doc == NULL ) error("Document not parsed successfully");

    ctx = xmlNewValidCtxt();
    if (ctx == NULL) error("Failed to allocate parser context");
    
    if (xmlValidateDocument(ctx, doc)!=1) error("Not validated");

    nod = xmlDocGetRootElement(doc);
    if (nod == NULL) 
    {
        xmlFreeDoc(doc);
        error("Empty document");
    }

    if (xmlStrcmp(nod->name, (const xmlChar *) "parratt")) 
    {
        xmlFreeDoc(doc);
        error("Document of the wrong type, root node != parratt");
    }
    /*====================================================*/

    /*----------------------------------
     * Determine the type of parratt.
     */
    buf = xmlGetProp(nod, (unsigned char*)"type");
    if      (strncmp((char *)buf,"parratt",7)==0)   par->s.pntp = PARRATT;
    else if (strncmp((char *)buf,"polarized",7)==0) par->s.pntp = POLARIZED;
    else error("Unknown parratt type");
    xmlFree(buf);
    if (par->s.pntp == PARRATT) fprintf(stdout, "Parratt: Parratt\n");
    else                        fprintf(stdout, "Parratt: Polarized Parratt\n");

    /*----------------------------------
     * Determine whether to do fitting.
     */
    buf = xmlGetProp(nod, (unsigned char*)"do_fit");
    if (strncmp((char *)buf,"yes",3)==0) par->s.doit = 1;
    else par->s.doit = 0;
    xmlFree(buf);
    if (par->s.doit) fprintf(stdout, "Parratt: Do fit: Yes\n");
    else             fprintf(stdout, "Parratt: Do fit: No\n");

    /*----------------------------------
     *  Run through the children of the root node
     *  If not fitting, then skip reading the fit section 
     */
    nod = nod->xmlChildrenNode;
    while (nod != NULL)
    {
        if ((!xmlStrcmp(nod->name, (const xmlChar *)"output")))
        {
            parseOutput(doc, nod, par);
        }
        if ((!xmlStrcmp(nod->name, (const xmlChar *)"model")))
        {
            parseModel(doc, nod, par);
        }
        if ((!xmlStrcmp(nod->name, (const xmlChar *)"fit")))
        {
            if (par->s.doit)  parseFit(doc, nod, par);
        }
        nod = nod->next;
    }
    
    xmlCleanupParser();
    return;
}

void parseOutput	(	xmlDocPtr	doc,
		xmlNodePtr	nod,
		Parratt *	par
	)

This function parses the children of the <output> tag. It performs error checking for the successfully reading of the data.

{
    xmlNodePtr  lay;
    xmlChar    *buf;
    int         i;
    
    lay = nod->xmlChildrenNode;
    while (lay != NULL)
    {
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"reflectivity")))
        {
            for (i=0; i<64; i++) par->s.refl[i]=0;
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            if (strlen((char *)buf) > 64) error("reflec. filename too big");
            strcpy(par->s.refl, (char *)buf);
            fprintf(stdout, "Parratt: Reflectivity file: %s\n", par->s.refl);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"profile")))
        {
            for (i=0; i<64; i++) par->s.prof[i]=0;
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            if (strlen((char *)buf) > 64) error("profile filename too big");
            strcpy(par->s.prof, (char *)buf);
            fprintf(stdout, "Parratt: Profile file: %s\n", par->s.prof);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"q_max")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->s.qmax);
            if (i!=1) error("Can't read q_max");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"q_min")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->s.qmin);
            if (i!=1) error("Can't read q_min");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"num_q")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%u",&par->s.numq);
            if (i!=1) error("Can't read num_q");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"num_z")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%u",&par->s.numz);
            if (i!=1) error("Can't read num_z");
            xmlFree(buf);
        }
        lay = lay->next;
    } 
    return;
}

void parseFit	(	xmlDocPtr	doc,
		xmlNodePtr	nod,
		Parratt *	par
	)

This function parses the children of the <fit> tag. It performs some error checking for the successful reading of the data.

{
    xmlNodePtr  lay;
    xmlChar    *type = NULL;
    xmlChar    *algo = NULL;
    xmlChar    *buf;
    char        i = 0, j = 0;
    
    lay = nod->xmlChildrenNode;
    while (lay != NULL)
    {
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"data")))
        {
            if (par->s.pntp == POLARIZED) error("Please provide </data_up>");
            
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            fprintf(stdout,"Parratt: Data file: %s\n", buf);
            if (strlen((char *)buf) > 50) error("Name too long");
            strcpy(par->d1.nam, (char *)buf);
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"data_up")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            fprintf(stdout,"Parratt: Data UP file: %s\n", buf);
            if (strlen((char *)buf) > 50) error("Name too long");
            strcpy(par->d1.nam, (char *)buf);
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"data_down")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            fprintf(stdout,"Parratt: Data DOWN file: %s\n", buf);
            if (strlen((char *)buf) > 50) error("Name too long");
            strcpy(par->d2.nam, (char *)buf);
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"weight")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            fprintf(stdout,"Parratt: Use weighting: %s\n", buf);
            if      (strncmp((char *)buf,"WEIGHT_NONE", 11)==0)       
                    par->d1.wgt = WEIGHT_NONE;
            else if (strncmp((char *)buf,"WEIGHT_R",     8)==0)       
                    par->d1.wgt = WEIGHT_R;
            else if (strncmp((char *)buf,"WEIGHT_SQRT", 11)==0)       
                    par->d1.wgt = WEIGHT_SQRT;
            else if (strncmp((char *)buf,"WEIGHT_ERR",  10)==0)       
                    par->d1.wgt = WEIGHT_ERR;
            else error("Unknown weighting");
            xmlFree(buf);
            par->d2.wgt = par->d1.wgt;
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"type")))
        {
            type = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            fprintf(stdout,"Parratt: Solver type: %s\n", type);
            i = 1;
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"algo")))
        {
            algo = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            fprintf(stdout,"Parratt: Solver algorithm: %s\n", algo);
            j = 1;
        }
        lay = lay->next;
    } 
    initMethod((char *)type, (char *)algo);
    if (i) xmlFree(type);
    if (j) xmlFree(algo);
    return;
}

void parseModel	(	xmlDocPtr	doc,
		xmlNodePtr	nod,
		Parratt *	par
	)

This function parses the children of the <model> tag. It performs error checking for the successful reading of the data.

{
    unsigned int i;
    xmlNodePtr      lay;
    xmlChar   *buf;
    
    lay = nod->xmlChildrenNode;
    while (lay != NULL)
    {
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"bulk")))
        {
            parseLayer(doc, lay, par, BULK);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"layer")))
        {
            parseLayer(doc, lay, par, LAYR);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"repeat")))
        {
            parseRepeat(doc, lay, par);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"substrate")))
        {
            parseLayer(doc, lay, par, SUBS);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"backgd")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->m.par[0]);
            if (i!=1) error("Can't read backgd");
            xmlFree(buf);
            
            buf = xmlGetProp(lay, (unsigned char *)"fix");
            i=sscanf((char *)buf,"%u",&par->m.fix[0]);
            if (i!=1) error("Can't read backgd fix");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"coverg")))
        {
            buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->m.par[1]);
            if (i!=1) error("Can't read coverg");
            xmlFree(buf);
            
            buf = xmlGetProp(lay, (unsigned char *)"fix");
            i=sscanf((char *)buf,"%u",&par->m.fix[1]);
            if (i!=1) error("Can't read coverg fix");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(lay->name, (const xmlChar *)"resoln")))
        {
            par->g.rl = SINGLE;
            
            buf = xmlGetProp(lay, (unsigned char *)"type");
            if (strncmp((char *)buf,"dq",3)==0) 
                               par->g.rtp = CONSTANT;
            else if (strncmp((char *)buf,"dq/q",3)==0) 
                               par->g.rtp = RELATIVE;
            else if (strncmp((char *)buf,"array-dq",9)==0)
            {
                       par->g.rtp = CONSTANT;
                       par->g.rl = ARRAY;
            }
            else if (strncmp((char *)buf,"array-dq/q",9)==0)
            {
                       par->g.rtp = RELATIVE;
                       par->g.rl = ARRAY;
            }
            else error("Can't read resolution type");
            xmlFree(buf);
            
            if (par->g.rl == SINGLE)
            {
                buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
                i=sscanf((char *)buf,"%lf",&par->g.rsn);
                if (i!=1) error("Can't read resoln");
                xmlFree(buf);
            }
            else if (par->g.rl == ARRAY)
            {
                for (i=0; i<64; i++) par->g.rnam[i]=0;
                buf = xmlNodeListGetString(doc, lay->xmlChildrenNode, 1);
                if (strlen((char *)buf) > 64) error("resolution filename too big");
                strcpy(par->g.rnam, (char *)buf);
                fprintf(stdout, "Parratt: Resolution file: %s\n", par->g.rnam);
                xmlFree(buf);               
            }
            else error("Resolution type not set properly");
            
            
        }
        lay = lay->next;
    } 
    return;
}

void parseLayer	(	xmlDocPtr	doc,
		xmlNodePtr	lay,
		Parratt *	par,
		int	type
	)

This function parses the children of the <layer> tag. It performs error checking for the successful reading of the data.

{
    unsigned int i, idx;
    xmlNodePtr cur;
    xmlChar   *buf;
    
    idx = par->m.num;
    cur = lay->xmlChildrenNode;
    while (cur != NULL) 
    {
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"name")))
        {
            buf = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            if (strlen((char *)buf) > 64) error("Name too long");
            strcpy(par->l.nam[par->l.num], (char *)buf);
            xmlFree(buf);
        }
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"thik")))
        {
            buf = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
            { 
                par->m.par[idx+0] = 0.0;
                par->m.fix[idx+0] = 1;
            }
            else
            {
                i=sscanf((char *)buf,"%lf",&par->m.par[idx+0]);
                if (i!=1) error("Can't read thik");
                xmlFree(buf);
            
                buf = xmlGetProp(cur, (unsigned char*)"fix");
                i=sscanf((char *)buf,"%u",&par->m.fix[idx+0]);
                if (i!=1) error("Can't read thik fix");
                xmlFree(buf);
            }
        }
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"sigz")))
        {
            buf = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
            { 
                par->m.par[idx+1] = 0.0;
                par->m.fix[idx+1] = 1;
            }
            else
            {
                i=sscanf((char *)buf,"%lf",&par->m.par[idx+1]);
                if (i!=1) error("Can't read sigz");
                xmlFree(buf);
            
                buf = xmlGetProp(cur, (unsigned char*)"fix");
                i=sscanf((char *)buf,"%u",&par->m.fix[idx+1]);
                if (i!=1) error("Can't read sigz fix");
                xmlFree(buf);
            }
        }
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"rsld")))
        {
            buf = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->m.par[idx+2]);
            if (i!=1) error("Can't read rsld");
            xmlFree(buf);
            
            buf = xmlGetProp(cur, (unsigned char*)"fix");
            i=sscanf((char *)buf,"%u",&par->m.fix[idx+2]);
            if (i!=1) error("Can't read rsld fix");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"isld")))
        {
            buf = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->m.par[idx+3]);
            if (i!=1) error("Can't read isld");
            xmlFree(buf);
            
            buf = xmlGetProp(cur, (unsigned char*)"fix");
            i=sscanf((char *)buf,"%u",&par->m.fix[idx+3]);
            if (i!=1) error("Can't read isld fix");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"rmag")))
        {
            buf = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->m.par[idx+4]);
            if (i!=1) error("Can't read rmag");
            xmlFree(buf);
            
            buf = xmlGetProp(cur, (unsigned char*)"fix");
            i=sscanf((char *)buf,"%u",&par->m.fix[idx+4]);
            if (i!=1) error("Can't read rmag fix");
            xmlFree(buf);
        }
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"imag")))
        {
            buf = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
            i=sscanf((char *)buf,"%lf",&par->m.par[idx+5]);
            if (i!=1) error("Can't read imag");
            xmlFree(buf);
            
            buf = xmlGetProp(cur, (unsigned char*)"fix");
            i=sscanf((char *)buf,"%u",&par->m.fix[idx+5]);
            if (i!=1) error("Can't read imag fix");
            xmlFree(buf);
        }
        cur = cur->next;
    }
    par->l.idx[par->l.num] = par->m.num;
    par->l.typ[par->l.num] = type;
    /*
     *  For each added layer, there are six new parameters.
     */
    par->m.num += 6;
    par->l.num += 1;
    return;
}       

void parseRepeat	(	xmlDocPtr	doc,
		xmlNodePtr	rep,
		Parratt *	par
	)

This function parses the children of the <repeat> tag. It performs error checking for the successful reading of the data.

{
    xmlNodePtr   curt;
    unsigned int rept[20];
    xmlChar     *buff;
    int          nl, nr, j, i=0;
    
    /*---------------
     * Get the number of repeats.
     */
    buff = xmlGetProp(rep, (unsigned char*)"num");
    i=sscanf((char *)buff,"%d",&nr);
    if (i!=1) error("Can't read repeat num");
    xmlFree(buff);
    
    /*----------------
     *   Parse the children of the repeat tag.
     *   Store the index in the rept array.
     */
    nl=0;
    curt = rep->xmlChildrenNode;
    while (curt != NULL) 
    {
        if ((!xmlStrcmp(curt->name, (const xmlChar *)"layer")))
        {
            rept[nl] = par->m.num;
            parseLayer(doc, curt, par, REPT);
            nl++;
        }
        curt = curt->next;
    }
    
    /*=====================================================
     *  Add to the layer's index array, pointing to the correct
     *  values of the parameters array.
     */
    for(i=1; i<nr; i++)
    {
        for(j=0; j<nl; j++)
        {
            /* Copy the layer name for each repeating layer */
            strcpy(par->l.nam[par->l.num], par->l.nam[par->l.num-nl]);
            
            /* The correct index is in the rept array */
            par->l.idx[par->l.num] = rept[j];
            
            /* The layer type is REPEAT */
            par->l.typ[par->l.num] = REPT;
            
            /* One more layer has been added */
            par->l.num += 1;
        }
    }

    return;
}

---