yanera_xml_output.c

Go to the documentation of this file.

/*==============================================================================
Copyright 2006 Thad Harroun, Kevin Yager

This file is part of "yanera 2.0".

"yanera 2.0" is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version.

"yanera 2.0" is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with "yanera 2.0"; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA 
==============================================================================*/ 
/*============================================================================*/
#define _CRT_SECURE_NO_DEPRECATE

#include "yanera.h"
#include "yanera_xml_output.h"
#include "yanera_xml_util.h"
/*============================================================================*/
void yanera_write_xml(yanera_container *yanera)
{
  short             i, j, k, r;
  xmlDocPtr         xml_doc;
  xmlDtdPtr         xml_dtd;
  xmlNodePtr        xml_root;
  xmlNodePtr        xml_node;
  xmlNodePtr        xml_section;
  xmlNodePtr        xml_node_data;
  xmlNodePtr        xml_node_resolution;
  xmlNodePtr        xml_node_model;
  xmlNodePtr        xml_node_layer;
  xmlNodePtr        xml_node_repeat;
  xmlNodePtr        xml_comment;
  yanera_layer     *layer;
  char              buf[80];
  
  /*---------------------------------
   *  Output in format with indents for each child.
   */
  xmlThrDefIndentTreeOutput(1);
  
  /*---------------------------------
   *  New document
   */
  xml_doc = xmlNewDoc((unsigned char*)"1.0");
  if (xml_doc == NULL )
  { 
    yanera_error("XML output document not created successfully", \
                 __FILE__, __LINE__, yanera);
  }
  /*---------------------------------
   * <!DOCTYPE reflect SYSTEM "reflect.dtd">
   */
  xml_dtd = xmlCreateIntSubset(xml_doc, (unsigned char *)"yanera", \
                               NULL, (unsigned char *)"yanera.dtd");
  if (xml_dtd == NULL ) 
  {
    yanera_error("XML DTD not created successfully", \
                 __FILE__, __LINE__, yanera);
  }
  /*---------------------------------
   *  Root node : yanera
   */
  xml_root = xmlNewDocNode(xml_doc, NULL, (unsigned char*)"yanera", NULL);
  xmlDocSetRootElement(xml_doc, xml_root);
  xml_comment = xmlNewComment((const xmlChar *)\
  " ====================================================================== ");
  xmlAddChild(xml_root,xml_comment);
  
  /*---------------------------------
   * <miscellaneous_section/> node 
   */
  xml_section = xmlNewChild(xml_root, NULL, \
                            (unsigned char*)"miscellaneous_section", \
                            NULL);  
  /*---------------------------------
   * <write_results/> node 
   */
  memset(buf, '\0', 30);
  setYesNoBooleanFromString((char *)buf,yanera->misc.write_results);
  xml_node = xmlNewTextChild(xml_section, NULL,               \
                             (unsigned char*)"write_results", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <write_profile/> node 
   */
  memset(buf, '\0', 30);
  setYesNoBooleanFromString((char *)buf,yanera->misc.write_profile);
  xml_node = xmlNewTextChild(xml_section, NULL,               \
                             (unsigned char*)"write_profile", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <write_reflectivity/> node 
   */
  memset(buf, '\0', 30);
  setYesNoBooleanFromString((char *)buf,yanera->misc.write_reflectivity);
  xml_node = xmlNewTextChild(xml_section, NULL,                    \
                             (unsigned char*)"write_reflectivity", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <write_slabs/> node 
   */
  memset(buf, '\0', 30);
  setYesNoBooleanFromString((char *)buf, yanera->misc.write_slabs);
  xml_node = xmlNewTextChild(xml_section, NULL,             \
                             (unsigned char*)"write_slabs", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <q_min/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%g",yanera->misc.q_min);
  xml_node = xmlNewTextChild(xml_section, NULL,       \
                             (unsigned char*)"q_min", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <q_max/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%g",yanera->misc.q_max);
  xml_node = xmlNewTextChild(xml_section, NULL,       \
                             (unsigned char*)"q_max", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <q_num/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%hd",yanera->misc.q_num);
  xml_node = xmlNewTextChild(xml_section, NULL,       \
                             (unsigned char*)"q_num", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <z_num/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%hd",yanera->misc.z_num);
  xml_node = xmlNewTextChild(xml_section, NULL,       \
                             (unsigned char*)"z_num", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <quadrature_error/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%g",yanera->misc.quadrature_error);
  xml_node = xmlNewTextChild(xml_section, NULL,                  \
                             (unsigned char*)"quadrature_error", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <quadrature_thik/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%g",yanera->misc.quadrature_thik);
  xml_node = xmlNewTextChild(xml_section, NULL,                  \
                             (unsigned char*)"quadrature_thik", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <do_fit/> node 
   */
  memset(buf, '\0', 30);
  setYesNoBooleanFromString((char *)buf, yanera->misc.fit_do);
  xml_node = xmlNewTextChild(xml_section, NULL,        \
                             (unsigned char*)"fit_do", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <fit_weighting/> node 
   */
  memset(buf, '\0', 30);
  switch (yanera->misc.fit_weighting) {
    case WEIGHT_NONE: 
      sprintf((char *)buf,"WEIGHT_NONE");
      break;
    case WEIGHT_R: 
      sprintf((char *)buf,"WEIGHT_R");
      break;
    case WEIGHT_SQRT: 
      sprintf((char *)buf,"WEIGHT_SQRT");
      break;
    case WEIGHT_DATA:
      sprintf((char *)buf,"WEIGHT_DATA");
      break;
    default: 
      break;
  }
  xml_node = xmlNewTextChild(xml_section, NULL,               \
                             (unsigned char*)"fit_weighting", \
                             (unsigned char*)buf);
                        
  /*---------------------------------
   * <fit_iterations/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%hd",yanera->misc.fit_iterations);
  xml_node = xmlNewTextChild(xml_section, NULL,       \
                             (unsigned char*)"fit_iterations", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <fit_write_iterations/> node 
   */
  memset(buf, '\0', 30);
  sprintf((char *)buf,"%hd",yanera->misc.fit_write_iterations);
  xml_node = xmlNewTextChild(xml_section, NULL,       \
                             (unsigned char*)"fit_write_iterations", \
                             (unsigned char*)buf);
  /*---------------------------------
   * <fit_weighting/> node 
   */
  memset(buf, '\0', 30);
  switch (yanera->misc.fit_method) {
    case CONJUGATE_FR: 
      sprintf((char *)buf,"CONJUGATE_FR");
      break;
    case CONJUGATE_PR: 
      sprintf((char *)buf,"CONJUGATE_PR");
      break;
    case VECTOR_BFGS: 
      sprintf((char *)buf,"VECTOR_BFGS");
      break;
    case STEEP_DESC:
      sprintf((char *)buf,"STEEP_DESC");
      break;
    case NMSIMPLEX:
      sprintf((char *)buf,"NMSIMPLEX");
      break;
    case SIMAN:
      sprintf((char *)buf,"SIMAN");
      break;
    case LMSDR:
      sprintf((char *)buf,"LMSDR");
      break;
    case LMDR:
      sprintf((char *)buf,"LMDR");
      break;
#ifdef HAVE_OOL
    case OOL_SPG: 
      sprintf((char *)buf,"OOL_SPG");
      break;
    case OOL_GENCAN: 
      sprintf((char *)buf,"OOL_GENCAN");
      break;
#endif
    case CLMSDR:
      sprintf((char *)buf,"CLMSDR");
      break;
    case CLMDR:
      sprintf((char *)buf,"CLMDR");
      break;
#ifdef HAVE_LEVMAR
    case LEVMAR:
      sprintf((char *)buf,"LEVMAR");
      break;
#endif
    default: 
      break;
  }
  xml_node = xmlNewTextChild(xml_section, NULL,               \
                             (unsigned char*)"fit_method", \
                             (unsigned char*)buf);
 
  xml_comment = xmlNewComment((const xmlChar *) \
  " ====================================================================== ");
  xmlAddChild(xml_root,xml_comment);

  /*---------------------------------
   * <data_section/> node 
   */
  xml_section = xmlNewChild(xml_root, NULL,                     \
                            (unsigned char*)"data_section", \
                            NULL);
  
  for (i=0; i<yanera->number_of_data; i++)
  {
    /*---------------------------------
     * Add a comment spacer before every <data/>
     */ 
    xml_comment = xmlNewComment((const xmlChar *)" ===== ");
    xmlAddChild(xml_section, xml_comment);
    
    /*---------------------------------
     *  <data/> node
     */
    xml_node_data = xmlNewChild(xml_section, NULL,         \
                                   (unsigned char*)"data", \
                                   NULL);
    memset(buf, '\0', 30);
    sprintf((char *)buf,"%s",yanera->data[i].data_id);
    xmlSetProp(xml_node_data, (unsigned char*)"data_id", \
                                  (unsigned char*)buf);
    
    xml_node = xmlNewTextChild(xml_node_data, NULL,    \
                               (unsigned char*)"file_name", \
                               (unsigned char*)yanera->data[i].file_name);
    xml_node_resolution  = xmlNewChild(xml_node_data, NULL, 
                                      (unsigned char*)"resolution", 
                                      NULL);
                                      
    memset(buf, '\0', 30);
    switch (yanera->data[i].resolution.type) {
      case RESOLUTION_NONE: 
        sprintf((char *)buf,"RESOLUTION_NONE");
        break;
      case RESOLUTION_CONSTANT: 
        sprintf((char *)buf,"RESOLUTION_CONSTANT");
        break;
      case RESOLUTION_RELATIVE: 
        sprintf((char *)buf,"RESOLUTION_RELATIVE");
        break;
      case RESOLUTION_ARRAY_CONSTANT: 
        sprintf((char *)buf,"RESOLUTION_ARRAY_CONSTANT");
        break;
      case RESOLUTION_ARRAY_RELATIVE: 
        sprintf((char *)buf,"RESOLUTION_ARRAY_RELATIVE");
        break;
      default: 
        break;
    }
    xml_node = xmlNewTextChild(xml_node_resolution, NULL, \
                                (unsigned char*)"type",     \
                                (unsigned char*)buf);
    memset(buf, '\0', 30);
    if (yanera->data[i].resolution.value != NULL)
    { 
      sprintf((char *)buf,"%g",yanera->data[i].resolution.value[0]); 
      xml_node = xmlNewTextChild(xml_node_resolution, NULL, \
                                (unsigned char*)"value",    \
                                (unsigned char*)buf);
    }
    else
    {
      xml_node = xmlNewTextChild(xml_node_resolution, NULL, \
                                (unsigned char*)"value",    \
                                (unsigned char*)NULL);
    }
    xml_node = xmlNewTextChild(xml_node_resolution, NULL, \
                       (unsigned char*)"file_name", \
                       (unsigned char*)yanera->data[i].resolution.file_name);
    
  }
  /*---------------------------------
   * Add a comment spacer before end of <data_section/>
   */      
  xml_comment = xmlNewComment((const xmlChar *)" ===== ");
  xmlAddChild(xml_section,xml_comment);
  
  /*---------------------------------
   * Add a large comment spacer between <data_section/> 
   * and <model_section/>
   */  
  xml_comment = xmlNewComment((const xmlChar *)\
  " ====================================================================== ");
  xmlAddChild(xml_root,xml_comment);

  /*---------------------------------
   * <model_section/> node 
   */
  xml_section = xmlNewChild(xml_root, NULL,                  \
                            (unsigned char*)"model_section", \
                            NULL);
  /*---------------------------------
   * Add a comment spacer before <model_type/>
   */
  xml_comment = xmlNewComment((const xmlChar *)" ===== ");
  xmlAddChild(xml_section, xml_comment);

  /*---------------------------------
   * <model_type/>
   */
  memset(buf, '\0', 30);
  switch (yanera->type) {
    case MODEL_LAYER: 
      sprintf((char *)buf,"MODEL_LAYER");
      break;
    case MODEL_SLAB: 
      sprintf((char *)buf,"MODEL_SLAB");
      break;
    case MODEL_COMPONENT: 
      sprintf((char *)buf,"MODEL_COMPONENT");
      break;
    case MODEL_FUNCTION: 
      sprintf((char *)buf,"MODEL_FUNCTION");
      break;
    default: 
      break;
  }
  xml_node = xmlNewTextChild(xml_section, NULL,            \
                             (unsigned char*)"model_type", \
                             (unsigned char*)buf);

  /*---------------------------------
   * <components/> 
   */
  layer = yanera->components;
  if (layer != NULL)
  {
     /*---------------------------------
     * Add a comment spacer after <model_type/>, before <component/>
     */
    xml_comment = xmlNewComment((const xmlChar *)" ===== ");
    xmlAddChild(xml_section, xml_comment);
  }
  while (layer != NULL)
  {
    xml_node_layer = xmlNewChild(xml_section, NULL, \
                                 (unsigned char*)"component", NULL);
    xmlLayer(xml_node_layer, layer, yanera);
    layer = layer->next;
  };

  /*---------------------------------
   * <model/>
   */
  for (i=0; i<yanera->number_of_models; i++) 
  {
    /*---------------------------------
     * Add a comment spacer  before every <model/>
     */
    xml_comment = xmlNewComment((const xmlChar *)" ===== ");
    xmlAddChild(xml_section, xml_comment);
    xml_node_model = xmlNewChild(xml_section, NULL,      \
                                (unsigned char*)"model", \
                                 NULL);   
                                 
    if (yanera->models_xml[i].data_idref != NULL)
    {
      xmlSetProp(xml_node_model, (unsigned char*)"data_idref", \
                 (unsigned char*)yanera->models_xml[i].data_idref);
    }

    if (yanera->models_xml[i].name != NULL)
    {
      xml_node = xmlNewTextChild(xml_node_model, NULL,  \
                                (unsigned char*)"name", \
                                (unsigned char*)yanera->models_xml[i].name);
    }
    if (yanera->models_xml[i].polarized != POLARIZED_NONE)
    {
      memset(buf, '\0', 30);
      if (yanera->models_xml[i].polarized == POLARIZED_UP) 
      { sprintf((char *)buf,"POLARIZED_UP"); }
      else if (yanera->models_xml[i].polarized == POLARIZED_DOWN)
      {  sprintf((char *)buf,"POLARIZED_DOWN"); }
      else if (yanera->models_xml[i].polarized == POLARIZED_UNPOLARIZED)
      {  sprintf((char *)buf,"POLARIZED_UNPOLARIZED"); }
      xml_node = xmlNewTextChild(xml_node_model, NULL,       \
                                (unsigned char*)"polarized", \
                                (unsigned char*)buf);
    }
    
    layer = yanera->models_xml[i].first_layer;
    while (layer != NULL)
    {
      switch (layer->type)
      {
        case LAYER_BULK:
          xml_node_layer = xmlNewChild(xml_node_model, NULL, \
                                       (unsigned char*)"bulk", NULL);
          xmlLayer(xml_node_layer, layer, yanera);
          layer = layer->next;
          break;
        case LAYER_LAYER:
        case LAYER_BOX:
        case LAYER_GAUSSIAN:
        case LAYER_FUNCTION:
          xml_node_layer = xmlNewChild(xml_node_model, NULL, \
                                      (unsigned char*)"layer", NULL);
          xmlLayer(xml_node_layer, layer, yanera);
          layer = layer->next;
          break;
        case LAYER_REPEAT:
          /*
           * Put a <repeat/> node
           */
          xml_node_repeat = xmlNewChild(xml_node_model, NULL, \
                                       (unsigned char*)"repeat", NULL);
          /*
           * Children of the <repeat/> node. All <layer/> in one 
           * repeating block have the same repeat_flag, so
           * add the next <layer/> until repeat_flag increments.
           */         
          j = layer->repeat_flag;
          do {
              xml_node_layer = xmlNewChild(xml_node_repeat, NULL, \
                                          (unsigned char*)"layer", NULL);
              xmlLayer(xml_node_layer, layer, yanera);
              layer = layer->next;
          } while (j == layer->repeat_flag);
          /*
           * Count the number of times this is repeated:
           * Loop through <layer/>, and every time repeat_flag is incremented,
           * then increment variable r. 
           * r=1 to start, because above, we have already added one.
           * i still is the original repeat_flag, and repeat_flag will 
           * start over at 0 with a new <repeat/>
           */       
          r = 1;
          while (j < layer->repeat_flag)
          {
            k = layer->repeat_flag;
            do {
              layer = layer->next;
            } while (k == layer->repeat_flag);
            r = r + 1;
          };
          memset(buf, '\0', 30);
          sprintf((char *)buf, "%d", r);
          xmlSetProp(xml_node_repeat, \
                    (unsigned char*)"number", (unsigned char *)buf);
          break;
        case LAYER_SUBSTRATE:
          xml_node_layer = xmlNewChild(xml_node_model, NULL, \
                                      (unsigned char*)"substrate", NULL);
          xmlLayer(xml_node_layer, layer, yanera);
          layer = layer->next;
          break;
        default:
          break;
      }
    }
  
    if (yanera->models_xml[i].background != -1)
    {
      memset(buf, '\0', 30);
      sprintf((char *)buf,"%g", \
          yanera->parameters.p[yanera->models_xml[i].background]);
      xml_node = xmlNewTextChild(xml_node_model, NULL,        \
                                (unsigned char*)"background", \
                                (unsigned char *)buf);
      memset(buf, '\0', 30);
      setYesNoBooleanFromString((char *)buf, \
          yanera->parameters.f[yanera->models_xml[i].background]);
      xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char *)buf);
      
      /* ----- */
      xmlMinMax(xml_node, yanera->models_xml[i].background, yanera);
      xmlParameterError(xml_node, yanera->models_xml[i].background, yanera);
    }
  }
  /*---------------------------------
   * Add a comment spacer after all the <model/>
   */
  xml_comment = xmlNewComment((const xmlChar *)" ===== ");
  xmlAddChild(xml_section,xml_comment);
  /*---------------------------------
   * Add a comment spacer after the <model_section/>
   */
  xml_comment = xmlNewComment((const xmlChar *)\
  " ====================================================================== ");  
  xmlAddChild(xml_root,xml_comment);  
  /*------------------------------------------------
   *   Write to file.
   */
  xmlSaveFormatFileEnc("result.xml", xml_doc, "ISO-8859-1", 1);
  xmlFreeDoc(xml_doc);  
  xmlCleanupParser();
  return;
}
/*============================================================================*/
void xmlLayer(xmlNodePtr xml_node_layer, \
              yanera_layer *layer, yanera_container *yanera)
{
  xmlNodePtr       xml_node;
  char             buf[30];
  short            i;
  
  if (layer->layer_id != NULL)
  {
    xmlSetProp(xml_node_layer, (unsigned char*)"layer_id", \
              (unsigned char*)layer->layer_id);
  }
  if (layer->layer_idref != NULL)
  {
    xmlSetProp(xml_node_layer, (unsigned char*)"layer_idref", \
              (unsigned char*)layer->layer_idref);
  }
  if (layer->component_id != NULL)
  {
    xmlSetProp(xml_node_layer, (unsigned char*)"component_id", \
              (unsigned char*)layer->component_id);
  }
  if (layer->component_idref != NULL)
  {
    xmlSetProp(xml_node_layer, (unsigned char*)"component_idref", \
              (unsigned char*)layer->component_idref);
  }
  /* 
   * Set the layer component type.
   */
  if (layer->type == LAYER_BOX)
  {
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"type", \
                               (unsigned char*)"box");
  }
  if (layer->type == LAYER_GAUSSIAN)
  {
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"type", \
                               (unsigned char*)"gaussian");
  }
  if (layer->type == LAYER_FUNCTION)
  {
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"type", \
                               (unsigned char*)"function");
  }
  /* 
   * Set the layer name;
   */ 
  if (layer->name != NULL)
  {
    xml_node = xmlNewTextChild(xml_node_layer, NULL,  \
                              (unsigned char*)"name", \
                              (unsigned char*)layer->name);
  }
  /* 
   * Set the layer function;
   */ 
  if (layer->func != NULL)
  {
    xml_node = xmlNewTextChild(xml_node_layer, NULL, \
                            (unsigned char*)"func",  \
                            (unsigned char*)layer->func);
  }
  if (layer->parm_names != NULL)
  {
    for(i=0; i<layer->number_of_parm; i++)
    {
      memset(buf, '\0', 30);
      sprintf(buf,"%g", yanera->parameters.p[layer->parm_values[i]]);
      xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                                 (unsigned char*)"parm", \
                                 (unsigned char*)buf);
      
      memset(buf, '\0', 30);
      sprintf((char *)buf,"%c",layer->parm_names[i]);                 
      xmlSetProp(xml_node, (unsigned char*)"name", \
                           (unsigned char*)buf);
      
      memset(buf, '\0', 30);
      setYesNoBooleanFromString((char *)buf, \
                                yanera->parameters.f[layer->parm_values[i]]);
      xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char*)buf);
      
      /* ------- */
      xmlMinMax(xml_node, layer->parm_values[i], yanera);
      xmlParameterError(xml_node, layer->parm_values[i], yanera);
    }
  }
  /* 
   * Set the layer thickness
   */
  if (layer->thik != -1) 
  {
    memset(buf, '\0', 30);
    if (layer->thik == -2) 
      sprintf((char *)buf,"n/a");
    else
      sprintf(buf,"%g", yanera->parameters.p[layer->thik]);
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"thik", \
                               (unsigned char*)buf);
    memset(buf, '\0', 30);
    if (layer->thik == -2) 
      sprintf((char *)buf,"yes");
    else
      setYesNoBooleanFromString((char *)buf,yanera->parameters.f[layer->thik]);
    xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char*)buf);
    
    /* ------- */
    xmlMinMax(xml_node, layer->thik, yanera);
    xmlParameterError(xml_node, layer->thik, yanera);
  }
  /* 
   * Set the layer roughness.
   */
  if (layer->sigz != -1) 
  {
    memset(buf, '\0', 30);
    if (layer->sigz == -2) 
      sprintf((char *)buf,"n/a");
    else
      sprintf((char *)buf,"%g", yanera->parameters.p[layer->sigz]);
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"sigz", \
                               (unsigned char*)buf);
    memset(buf, '\0', 30);
    if (layer->sigz == -2) 
      sprintf((char *)buf,"yes");
    else
      setYesNoBooleanFromString((char *)buf,yanera->parameters.f[layer->sigz]);
    xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char*)buf);
    
    /* ------- */
    xmlMinMax(xml_node, layer->sigz, yanera);
    xmlParameterError(xml_node, layer->sigz, yanera);
  }
  /* 
   * Set the layer center.
   */
  if (layer->cntr != -1) 
  {
    memset(buf, '\0', 30);
    if (layer->cntr == -2) 
      sprintf((char *)buf,"n/a");
    else
      sprintf((char *)buf,"%g", yanera->parameters.p[layer->cntr]);
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"cntr", \
                               (unsigned char*)buf);
    memset(buf, '\0', 30);
    if (layer->cntr == -2) 
      sprintf((char *)buf,"yes");
    else
      setYesNoBooleanFromString((char *)buf,yanera->parameters.f[layer->cntr]);
    xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char*)buf);
    
    /* ------- */
    xmlMinMax(xml_node, layer->cntr, yanera);
    xmlParameterError(xml_node, layer->cntr, yanera);
  }
  /* 
   * Set the layer real sld.
   */
  if (layer->rsld != -1) 
  {
    memset(buf, '\0', 30);
    if (layer->rsld == -2) 
      sprintf((char *)buf,"n/a");
    else
      sprintf(buf,"%g", yanera->parameters.p[layer->rsld]);
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"rsld", \
                               (unsigned char*)buf);
    memset(buf, '\0', 30);
    if (layer->rsld == -2) 
      sprintf((char *)buf,"yes");
    else
      setYesNoBooleanFromString((char *)buf,yanera->parameters.f[layer->rsld]);
    xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char*)buf);
    
    /* ------- */
    xmlMinMax(xml_node, layer->rsld, yanera);
    xmlParameterError(xml_node, layer->rsld, yanera);
  } 
  /* 
   * Set the layer imaginary sld.
   */
  if (layer->isld != -1) 
  {
    memset(buf, '\0', 30);
    if (layer->isld == -2) 
      sprintf((char *)buf,"n/a");
    else
      sprintf(buf,"%g", yanera->parameters.p[layer->isld]);
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"isld", \
                               (unsigned char*)buf);
    memset(buf, '\0', 30);
    if (layer->isld == -2) 
      sprintf((char *)buf,"yes");
    else
      setYesNoBooleanFromString((char *)buf,yanera->parameters.f[layer->isld]);
    xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char*)buf);
    
    /* ------- */
    xmlMinMax(xml_node, layer->isld, yanera);
    xmlParameterError(xml_node, layer->isld, yanera);
  }   
  /* 
   * Set the layer real magnetic sld.
   */
  if (layer->rmag != -1) 
  {
    memset(buf, '\0', 30);
    if (layer->rmag == -2) 
      sprintf((char *)buf,"n/a");
    else
      sprintf(buf,"%g", yanera->parameters.p[layer->rmag]);
    xml_node = xmlNewTextChild(xml_node_layer, NULL,   \
                               (unsigned char*)"rmag", \
                               (unsigned char*)buf);
    memset(buf, '\0', 30);
    if (layer->rmag == -2) 
      sprintf((char *)buf,"yes");
    else
      setYesNoBooleanFromString((char *)buf,yanera->parameters.f[layer->rmag]);
    xmlSetProp(xml_node, (unsigned char*)"fix", (unsigned char*)buf);
    
    /* ------- */
    xmlMinMax(xml_node, layer->rmag, yanera);
    xmlParameterError(xml_node, layer->rmag, yanera);
  }   
  /* 
   * Set the layer include.
   */
  if (layer->include_flag == NO) 
  {

    xml_node = xmlNewTextChild(xml_node_layer, NULL,      \
                               (unsigned char*)"include", \
                               (unsigned char*)"no");
  }  

  return;
}
/*============================================================================*/
void xmlMinMax(xmlNodePtr xml_node_layer_item, short parm_index, \
               yanera_container *yanera)
{
  xmlNodePtr xml_node;
  char             buf[30];
    
  if ((yanera->parameters.con[parm_index] == CONSTRAIN_MIN) ||
      (yanera->parameters.con[parm_index] == CONSTRAIN_BOTH))
  {
    memset(buf, '\0', 30);
    sprintf(buf,"%g", yanera->parameters.min[parm_index]);
    xml_node = xmlNewTextChild(xml_node_layer_item, NULL,   \
                               (unsigned char*)"min", \
                               (unsigned char*)buf);
  }
  if ((yanera->parameters.con[parm_index] == CONSTRAIN_MAX) ||
      (yanera->parameters.con[parm_index] == CONSTRAIN_BOTH))
  {
    memset(buf, '\0', 30);
    sprintf(buf,"%g", yanera->parameters.max[parm_index]);
    xml_node = xmlNewTextChild(xml_node_layer_item, NULL,   \
                               (unsigned char*)"max", \
                               (unsigned char*)buf);
  }
  
  return;
}
/*============================================================================*/
void xmlParameterError(xmlNodePtr xml_node_layer_item, short parm_index, \
              yanera_container *yanera)
{
  xmlNodePtr xml_node;
  char       buf[30];
  
  if ((yanera->misc.fit_do == YES) &&
      (parm_index >= 0))
  {
    memset(buf, '\0', 30);
    sprintf(buf,"%g", yanera->parameters.tmp[parm_index]);
    xml_node = xmlNewTextChild(xml_node_layer_item, NULL,   \
                               (unsigned char*)"err", \
                               (unsigned char*)buf);
  }
  return;
}

---