pxmlo.c File Reference


Detailed Description

This file contains the functions for XML output. Currently, the XML output file is called "result.xml". Would it be useful to choose another name?


Functions

void reportParratt (Parratt *par)
 Write the results to the file result.xml.
void xmlLayer (Parratt *par, xmlNodePtr layer, int i)
 Add a layer to the XML structure for output.


Function Documentation

void reportParratt ( Parratt par  ) 

This function writes an XML file reporting the result of the fitting. It should be the same as the input file format, and could be parsed again as input. If not fitting then the </fit> section is skipped.

00026 {
00027     unsigned int     i, j, k, r;
00028     xmlDocPtr        doc;
00029     xmlNodePtr       root;
00030     xmlNodePtr       model;
00031     xmlNodePtr       layer;
00032     xmlNodePtr       repeat;
00033     xmlNodePtr       value;
00034     xmlNodePtr       output;
00035     xmlNodePtr       fit;
00036     xmlDtdPtr        dtd;
00037     unsigned char    buf[20];
00038 
00039     /*
00040      *  Output in format with indents for each child.
00041      */
00042     xmlThrDefIndentTreeOutput(1);
00043     
00044     /*
00045      *  New document
00046      */
00047     doc = xmlNewDoc((unsigned char*)"1.0");
00048     if (doc == NULL ) error("XML document not alloc'd successfully");
00049 
00050     /*
00051      * <!DOCTYPE parratt SYSTEM "parratt.dtd">
00052      */
00053     dtd = xmlCreateIntSubset(doc, (unsigned char *)"parratt", \
00054                                   NULL, \
00055                                   (unsigned char *)"parratt.dtd");
00056     
00057     /*---------------------------------
00058      *  Root node : parratt
00059      */
00060 
00061     root = xmlNewDocNode(doc, NULL, (unsigned char*)"parratt", NULL);
00062     if (par->s.pntp == POLARIZED)
00063         xmlSetProp(root, (unsigned char*)"type", (unsigned char*)"polarized");
00064     else
00065         xmlSetProp(root, (unsigned char*)"type", (unsigned char*)"parratt");
00066     if (par->s.doit == 1)
00067         xmlSetProp(root, (unsigned char*)"do_fit", (unsigned char*)"yes");
00068     else
00069         xmlSetProp(root, (unsigned char*)"do_fit", (unsigned char*)"no");
00070     xmlDocSetRootElement(doc, root);
00071 
00072     /*---------------------------------
00073      * Output node 
00074      */
00075     output = xmlNewChild(root, NULL, (unsigned char*)"output", NULL);
00076     value = xmlNewTextChild(output, NULL, 
00077                             (unsigned char*)"reflectivity", 
00078                             (unsigned char*)par->s.refl);
00079     value = xmlNewTextChild(output, NULL, 
00080                             (unsigned char*)"profile", 
00081                             (unsigned char*)par->s.prof);
00082     for (k=0; k<20; k++) buf[k] = 0;
00083     sprintf((char *)buf,"%6.3f",par->s.qmin);
00084     value = xmlNewTextChild(output, NULL, 
00085                            (unsigned char*)"q_min", 
00086                            (unsigned char*)buf);
00087     for (k=0; k<20; k++) buf[k] = 0;
00088     sprintf((char *)buf,"%6.3f",par->s.qmax);
00089     value = xmlNewTextChild(output, NULL, 
00090                            (unsigned char*)"q_max", 
00091                            (unsigned char*)buf);
00092     for (k=0; k<20; k++) buf[k] = 0;
00093     sprintf((char *)buf,"%d",par->s.numq);
00094     value = xmlNewTextChild(output, NULL, 
00095                            (unsigned char*)"num_q", 
00096                            (unsigned char*)buf);
00097     for (k=0; k<20; k++) buf[k] = 0;
00098     sprintf((char *)buf,"%d",par->s.numz);
00099     value = xmlNewTextChild(output, NULL, 
00100                            (unsigned char*)"num_z", 
00101                            (unsigned char*)buf);
00102 
00103     /*---------------------------------
00104      * Fit node
00105      */
00106     if (par->s.doit)
00107     {
00108     fit = xmlNewChild(root, NULL, (unsigned char*)"fit", NULL);
00109     if (par->s.pntp == POLARIZED)
00110     {
00111         value = xmlNewTextChild(fit, NULL,                  \
00112                                (unsigned char*)"data_up",   \
00113                                (unsigned char*)par->d1.nam);
00114         value = xmlNewTextChild(fit, NULL,                  \
00115                                (unsigned char*)"data_down", \
00116                                (unsigned char*)par->d2.nam);
00117     }
00118     else
00119     {
00120         value = xmlNewTextChild(fit, NULL,                  \
00121                                (unsigned char*)"data", \
00122                                (unsigned char*)par->d1.nam);
00123     
00124     }
00125     
00126     if (par->d1.wgt == 0)
00127         value = xmlNewTextChild(fit, NULL, 
00128                                 (unsigned char*)"weight", 
00129                                 (unsigned char*)"WEIGHT_NONE");
00130     else if (par->d1.wgt == 1)
00131         value = xmlNewTextChild(fit, NULL, 
00132                                 (unsigned char*)"weight", 
00133                                 (unsigned char*)"WEIGHT_R");
00134     else if (par->d1.wgt == 2)
00135         value = xmlNewTextChild(fit, NULL, 
00136                                 (unsigned char*)"weight", 
00137                                 (unsigned char*)"WEIGHT_SQRT");
00138     else if (par->d1.wgt == 3)
00139         value = xmlNewTextChild(fit, NULL, 
00140                                 (unsigned char*)"weight", 
00141                                 (unsigned char*)"WEIGHT_ERR");
00142     if (fit_method.solv_type == &mdmin_main)
00143     {
00144         value = xmlNewTextChild(fit, NULL, 
00145                                 (unsigned char*)"type", 
00146                                 (unsigned char*)"MULTIDIM_MINIMIZAION");
00147         if (fit_method.mdmin_type ==  
00148                       gsl_multimin_fdfminimizer_conjugate_fr)
00149         {
00150             value = xmlNewTextChild(fit, NULL, 
00151                                 (unsigned char*)"algo", 
00152                                 (unsigned char*)"CONJUGATE_FR");
00153         }
00154         else if (fit_method.mdmin_type ==  
00155                       gsl_multimin_fdfminimizer_conjugate_pr)
00156         {
00157             value = xmlNewTextChild(fit, NULL, 
00158                                 (unsigned char*)"algo", 
00159                                 (unsigned char*)"CONJUGATE_PR");
00160         }
00161         else if (fit_method.mdmin_type ==  
00162                       gsl_multimin_fdfminimizer_vector_bfgs)
00163         {
00164             value = xmlNewTextChild(fit, NULL, 
00165                                 (unsigned char*)"algo", 
00166                                 (unsigned char*)"VECTOR_BFGS");
00167         }
00168         else if (fit_method.mdmin_type ==  
00169                       gsl_multimin_fdfminimizer_steepest_descent)
00170         {
00171             value = xmlNewTextChild(fit, NULL, 
00172                                 (unsigned char*)"algo", 
00173                                 (unsigned char*)"STEEP_DESC");
00174         }
00175     }
00176     else if (fit_method.solv_type == &lstsq_main)
00177     {
00178         value = xmlNewTextChild(fit, NULL, 
00179                                 (unsigned char*)"type", 
00180                                 (unsigned char*)"LEAST_SQUARES");
00181         if (fit_method.lstsq_type ==  
00182                       gsl_multifit_fdfsolver_lmsder)
00183         {
00184             value = xmlNewTextChild(fit, NULL, 
00185                                 (unsigned char*)"algo", 
00186                                 (unsigned char*)"LMSDR");
00187         }
00188         else if (fit_method.lstsq_type ==  
00189                       gsl_multifit_fdfsolver_lmder)
00190         {
00191             value = xmlNewTextChild(fit, NULL, 
00192                                 (unsigned char*)"algo", 
00193                                 (unsigned char*)"LMDR");
00194         }
00195     }
00196     else if (fit_method.solv_type == &siman_main)
00197     {
00198         value = xmlNewTextChild(fit, NULL, 
00199                                 (unsigned char*)"type", 
00200                                 (unsigned char*)"SIMULATED_ANNEAL");
00201         value = xmlNewTextChild(fit, NULL, 
00202                                 (unsigned char*)"algo", 
00203                                 (unsigned char*)"SIMULATED_ANNEAL");
00204     }
00205     }
00206     /*---------------------------------
00207      * Model node 
00208      */
00209     model = xmlNewChild(root, NULL, (unsigned char*)"model", NULL);
00210     for (i=0; i<par->l.num; i++)
00211     {
00212         if (par->l.typ[i] == BULK)
00213         {
00214             layer = xmlNewChild(model, NULL, 
00215                             (unsigned char*)"bulk", NULL);
00216             xmlLayer(par, layer, i);                   
00217         }
00218         else if (par->l.typ[i] == SUBS)
00219         {
00220             layer = xmlNewChild(model, NULL, 
00221                             (unsigned char*)"substrate", NULL);
00222             xmlLayer(par, layer, i);                   
00223         }
00224         else if  (par->l.typ[i] == REPT)
00225         {
00226             repeat = xmlNewChild(model, NULL, 
00227                             (unsigned char*)"repeat", NULL);
00228             /*------------------------------
00229              * This bit is tricky. It should write out one
00230              * copy of a repeat unit.
00231              *
00232              * It starts by adding layers as children to the repeat
00233              * tag until the index arrives back a the start.
00234              * There are then k layers in the repeat unit. 
00235              */
00236             j = i;
00237             k = 0;
00238             do 
00239             {
00240                 layer = xmlNewChild(repeat, NULL, 
00241                                 (unsigned char*)"layer", NULL);
00242                 xmlLayer(par, layer, i);
00243                 i += 1;
00244                 k += 1;                
00245             } while (par->l.idx[i] != par->l.idx[j]);
00246             /*-------------------------------------
00247              *  Keep skiping forward in the index array 
00248              * k spaces until the index array changes.
00249              * There are then r repeating units.
00250              */
00251             r = 1;                      
00252             do
00253             {
00254                 i += k; 
00255                 r += 1;            
00256             } while (par->l.idx[i] == par->l.idx[j]) ;  
00257                             
00258             for (k=0; k<20; k++) buf[k] = 0;
00259             sprintf((char *)buf,"%d",r);
00260             xmlSetProp(repeat, (unsigned char*)"num", buf);
00261             /*-------------------------------------
00262              *  Back off one layer so that the loop works properly 
00263              */
00264             i -= 1;
00265         }
00266         else
00267         {
00268             layer = xmlNewChild(model, NULL, 
00269                                 (unsigned char*)"layer", NULL);
00270             xmlLayer(par, layer, i);                   
00271         }
00272     }
00273     /*
00274      *
00275      */
00276     for (k=0; k<20; k++) buf[k] = 0;
00277     sprintf((char *)buf,"%6.3f",par->m.par[1]);
00278     value = xmlNewTextChild(model, NULL, 
00279                                    (unsigned char*)"coverg", 
00280                                    (unsigned char*)buf);
00281     for (k=0; k<20; k++) buf[k] = 0;
00282     sprintf((char *)buf,"%d",par->m.fix[1]);
00283     xmlSetProp(value, (unsigned char*)"fix", buf);
00284     /*
00285      *
00286      */
00287     for (k=0; k<20; k++) buf[k] = 0;
00288     sprintf((char *)buf,"%6.3f",par->m.par[0]);
00289     value = xmlNewTextChild(model, NULL, 
00290                                    (unsigned char*)"backgd", 
00291                                    (unsigned char*)buf);
00292     for (k=0; k<20; k++) buf[k] = 0;
00293     sprintf((char *)buf,"%d",par->m.fix[0]);
00294     xmlSetProp(value, (unsigned char*)"fix", buf);
00295     /*
00296      *
00297      */
00298     for (k=0; k<20; k++) buf[k] = 0;
00299     sprintf((char *)buf,"%6.3f",par->g.rsn);
00300     value = xmlNewTextChild(model, NULL, 
00301                                    (unsigned char*)"resoln", 
00302                                    (unsigned char*)buf);
00303     if (par->g.rtp == CONSTANT)
00304         xmlSetProp(value, (unsigned char*)"type", (unsigned char*)"dq");
00305     else
00306         xmlSetProp(value, (unsigned char*)"type", (unsigned char*)"dq/q");  
00307     /*------------------------------------------------
00308      *   Write to file.
00309      */
00310     xmlSaveFormatFile("result.xml", doc, 1);
00311     
00312     return;
00313 }

void xmlLayer ( Parratt par,
xmlNodePtr  layer,
int  i 
)

This function handles wrint a single layer to the XML tree.

00316 {
00317     int j, k;
00318     unsigned char    buf[20];
00319     xmlNodePtr       value;
00320 
00321     value = xmlNewTextChild(layer, NULL, 
00322                             (unsigned char*)"name", 
00323                             (unsigned char*)par->l.nam[i]);
00324     j = par->l.idx[i];
00325 
00326     for (k=0; k<20; k++) buf[k] = 0;
00327     if (par->m.par[j+0] == 0) sprintf((char *)buf,"%s","n/a");
00328     else sprintf((char *)buf,"%6.3f",par->m.par[j+0]);
00329     value = xmlNewTextChild(layer, NULL, 
00330                                 (unsigned char*)"thik", 
00331                                 (unsigned char*)buf);
00332                                 
00333     for (k=0; k<20; k++) buf[k] = 0;
00334     sprintf((char *)buf,"%d",par->m.fix[j+0]);
00335     xmlSetProp(value, (unsigned char*)"fix", buf);
00336                                 
00337     for (k=0; k<20; k++) buf[k] = 0;
00338     if (par->m.par[j+1] == 0) sprintf((char *)buf,"%s","n/a");
00339     else sprintf((char *)buf,"%6.3f",par->m.par[j+1]);
00340     value = xmlNewTextChild(layer, NULL, 
00341                                 (unsigned char*)"sigz", 
00342                                 (unsigned char*)buf);
00343                                 
00344     for (k=0; k<20; k++) buf[k] = 0;
00345     sprintf((char *)buf,"%d",par->m.fix[j+1]);
00346     xmlSetProp(value, (unsigned char*)"fix", buf);
00347                                 
00348     for (k=0; k<20; k++) buf[k] = 0;
00349     sprintf((char *)buf,"%6.3f",par->m.par[j+2]);
00350     value = xmlNewTextChild(layer, NULL, 
00351                                 (unsigned char*)"rsld", 
00352                                 (unsigned char*)buf);
00353                                 
00354     for (k=0; k<20; k++) buf[k] = 0;
00355     sprintf((char *)buf,"%d",par->m.fix[j+2]);
00356     xmlSetProp(value, (unsigned char*)"fix", buf);
00357     
00358     if (par->m.par[j+3] != 0.0)
00359     {
00360         for (k=0; k<20; k++) buf[k] = 0;
00361         sprintf((char *)buf,"%6.3f",par->m.par[j+3]);
00362         value = xmlNewTextChild(layer, NULL, 
00363                                     (unsigned char*)"isld", 
00364                                     (unsigned char*)buf);
00365                                 
00366         for (k=0; k<20; k++) buf[k] = 0;
00367         sprintf((char *)buf,"%d",par->m.fix[j+3]);
00368         xmlSetProp(value, (unsigned char*)"fix", buf);
00369     }
00370     if (par->m.par[j+4] != 0.0)
00371     {
00372         for (k=0; k<20; k++) buf[k] = 0;
00373         sprintf((char *)buf,"%6.3f",par->m.par[j+4]);
00374         value = xmlNewTextChild(layer, NULL, 
00375                                         (unsigned char*)"rmag", 
00376                                         (unsigned char*)buf);
00377                             
00378         for (k=0; k<20; k++) buf[k] = 0;
00379         sprintf((char *)buf,"%d",par->m.fix[j+4]);
00380         xmlSetProp(value, (unsigned char*)"fix", buf);  
00381     }
00382     
00383     if (par->m.par[j+5] != 0.0)
00384     {
00385         for (k=0; k<20; k++) buf[k] = 0;
00386         sprintf((char *)buf,"%6.3f",par->m.par[j+5]);
00387         value = xmlNewTextChild(layer, NULL, 
00388                                     (unsigned char*)"imag", 
00389                                         (unsigned char*)buf);
00390                             
00391         for (k=0; k<20; k++) buf[k] = 0;
00392         sprintf((char *)buf,"%d",par->m.fix[j+5]);
00393         xmlSetProp(value, (unsigned char*)"fix", buf);
00394     }
00395 
00396     return;
00397 }


Generated on Wed Mar 14 13:24:56 2007 for Parratt by  doxygen 1.4.7