yanera_xml_input.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_input.h"
#include "yanera_util.h"
#include "yanera_xml_util.h"
#include "yanera_reflectivity.h"
#include "yanera_profile.h"
/*============================================================================*/
void yanera_read_xml(yanera_container *yanera) 
{
  xmlValidCtxtPtr  xml_ctxt; 
  xmlDocPtr        xml_doc;
  xmlNodePtr       xml_node;
 
  /*====================================================
   *  Bunch of error checking and document validation
   */
  xmlSetStructuredErrorFunc(NULL, xmlErrorFunc);
   
  xml_doc = xmlParseFile(yanera->filename);
  if (xml_doc == NULL )
  {
    yanera_error("XML document not parsed successfully", \
     __FILE__, __LINE__, yanera);
  }
    
  xml_ctxt = xmlNewValidCtxt();
  if (xml_ctxt == NULL) 
  {
    yanera_error("Failed to allocate XML parser context", \
                 __FILE__, __LINE__, yanera);
  }
  if (xmlValidateDocument(xml_ctxt, xml_doc)!=1)
  {
    yanera_error("XML document not validated.", __FILE__, __LINE__, yanera);
  }
  if (xmlValidateDocumentFinal(xml_ctxt, xml_doc)!=1)
  {
     yanera_error("XML document not validated.", __FILE__, __LINE__, yanera);
  }
  xmlFreeValidCtxt(xml_ctxt);
  
  xml_node = xmlDocGetRootElement(xml_doc);
  if (xml_node == NULL) 
  {
    xmlFreeDoc(xml_doc);
    yanera_error("Empty XML document.", yanera->filename, 0, yanera);
  }

  if (xmlStrcmp(xml_node->name, (const xmlChar *) "yanera")) 
  {
    xmlFreeDoc(xml_doc);
    yanera_error("XML document of the wrong type: root node is not <yanera/>", \
                  yanera->filename, xml_node->line, yanera);
  }
  /*====================================================*/

  /*----------------------------------
   *  Run through the children of the root node.
   *  <miscellaneous_section/>
   *  <data_section/>
   *  <model_section/>
   */
  xml_node = xml_node->xmlChildrenNode;
  while (xml_node != NULL)
  {
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"miscellaneous_section")))
    {
      parseMiscellaneousSection(xml_doc, xml_node, yanera);
    }
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"data_section")))
    {
      parseDataSection(xml_doc, xml_node, yanera);
    }
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"model_section")))
    {
      parseModelSection(xml_doc, xml_node, yanera);
    }
    xml_node = xml_node->next;
  }
  
  /*
   * Free memory used by libxml
   */
  xmlFreeDoc(xml_doc);
  xmlCleanupParser();
  return;
}
/*============================================================================*/
void parseModelSection(xmlDocPtr xml_doc, xmlNodePtr xml_parent_node, \
                       yanera_container *yanera) 
{
  xmlNodePtr     xml_node;
  xmlChar       *buf;
  yanera_layer  *layer;
  
  xml_node = xml_parent_node->xmlChildrenNode;
  while (xml_node != NULL)
  {
    /*
     *  Get the model_type
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"model_type")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if      (strncmp((char *)buf,"MODEL_LAYER", 11)==0) 
      {
        yanera->type = MODEL_LAYER;
        yanera->parrattFunction = &calcParrattFromModel;
        yanera->profileFunctionReal = &layerProfileReal;
        yanera->profileFunctionImag = &layerProfileImag;
      }
      else if (strncmp((char *)buf,"MODEL_COMPONENT", 15)==0) 
      {
        yanera->type = MODEL_COMPONENT;
        yanera->parrattFunction = &calcParrattFromSlabs;
        yanera->profileFunctionReal = &componentProfileReal;
        yanera->profileFunctionImag = &componentProfileImag;
      }
      else if (strncmp((char *)buf,"MODEL_SLAB", 10)==0) 
      {
        yanera->type = MODEL_SLAB;
        yanera->parrattFunction = &calcParrattFromSlabs;
        yanera->profileFunctionReal = &layerProfileReal;
        yanera->profileFunctionImag = &layerProfileImag;
      }
      else if (strncmp((char *)buf,"MODEL_FUNCTION", 14)==0) 
      {
        yanera->type = MODEL_FUNCTION;
        yanera->parrattFunction = &calcParrattFromSlabs;
        yanera->profileFunctionReal = &functionProfileReal;
        yanera->profileFunctionImag = &functionProfileImag;
      }
      else
      {
        yanera_error("Incorrect <model_type/>", \
                      yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
    }
    /*
     * Get the model
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"model")))
    {
      /*
       *  Get the data_idref of the model
       */
      buf = xmlGetProp(xml_node, (unsigned char*)"data_idref");
      yanera->models_xml[yanera->number_of_models].data_idref = \
          (char *)calloc((strlen((const char *)buf)+1), sizeof(char));
      strcpy(yanera->models_xml[yanera->number_of_models].data_idref, \
             (char *)buf);
      xmlFree(buf);
      /*
       * Parse the model.
       */
      parseModel(xml_doc, xml_node, \
                 &yanera->models_xml[yanera->number_of_models], yanera);
      yanera->number_of_models += 1;
    }
    /*
     * Get the components, if any.
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"component")))
    {
      layer = newLayer(LAYER_COMPONENT);
      linkComponentIntoContainer(layer, yanera);
      parseLayer(xml_doc, xml_node, layer, yanera);
    }
    
    xml_node = xml_node->next;
  } 
  return;
}
/*============================================================================*/
void parseModel(xmlDocPtr xml_doc, xmlNodePtr xml_node_model, \
                yanera_model *model, yanera_container *yanera) 
{
  unsigned short i1, i2;
  short          i3;
  double         d1;
  xmlNodePtr     xml_node;
  xmlChar       *buf;
  yanera_layer  *layer;
  
  xml_node = xml_node_model->xmlChildrenNode;
  while (xml_node != NULL)
  {
    /*
     * <name>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"name")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      model->name = (char *)calloc((strlen((const char *)buf)+1),sizeof(char));
      strcpy(model->name, (char *)buf);
      xmlFree(buf);
    }
    /*
     * <polarized>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"polarized")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if      (strncmp((char *)buf,"POLARIZED_UP", 12)==0) 
        model->polarized = POLARIZED_UP;
      else if (strncmp((char *)buf,"POLARIZED_DOWN", 14)==0) 
        model->polarized = POLARIZED_DOWN;
      else if (strncmp((char *)buf,"POLARIZED_UNPOLARIZED", 21)==0) 
        model->polarized = POLARIZED_UNPOLARIZED;
      else 
      {
        yanera_error("Incorrect <polarized/>", \
                      yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <bulk>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"bulk")))
    {
      layer = newLayer(LAYER_BULK);
      linkLayerIntoModel(layer, model);
      parseLayer(xml_doc, xml_node, layer, yanera);
    }
    /*
     * <layer>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"layer")))
    {
      layer = newLayer(LAYER_LAYER);
      linkLayerIntoModel(layer, model);
      parseLayer(xml_doc, xml_node, layer, yanera);
    }
    /*
     * <repeat> and its property "number".
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"repeat")))
    {
      buf = xmlGetProp(xml_node, (unsigned char*)"number");
      i2=sscanf((char *)buf, "%hu", &i1);
      if (i2!=1) 
      {
        yanera_error("Can't read <repeat/> number property.", \
                     yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
      parseRepeat(xml_doc, xml_node, i1, model, yanera);
    }
    /*
     * <substrate>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"substrate")))
    {
      layer = newLayer(LAYER_SUBSTRATE);
      linkLayerIntoModel(layer, model);
      parseLayer(xml_doc, xml_node, layer, yanera);
    }
    /*
     * <background> : The only node type parsed without need for another 
     * function call.
     */
     if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"background")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&d1);
      if (i2!=1) 
      {
        yanera_error("Can't read background", \
                      yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
      
      buf = xmlGetProp(xml_node, (unsigned char*)"fix");
      i3 = getYesNoBooleanFromString((char *)buf);
      if (i3 == ERROR)
      {
        yanera_error("Can't read background fix", \
                      yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
        
      model->background = newParameter(d1, i3, yanera); 
      
      /* ---- */
      parseMinMax(xml_doc,xml_node,model->background,yanera);
    }
    xml_node = xml_node->next;
  } 
}
/*============================================================================*/
void parseLayer(xmlDocPtr xml_doc, xmlNodePtr xml_node_layer, \
                yanera_layer *layer, yanera_container *yanera) 
{
  short          i1, i2;
  double         d1;
  char           c1;
  xmlNodePtr     xml_node;
  xmlChar       *buf;
  
  /*---------------------------------------------------------------------------
   *  ID's and IDREF's are XML properties and not children of <layer/>
   */
  /*
   *  Get the component_id of the layer
   */
  buf = xmlGetProp(xml_node_layer, (unsigned char*)"component_id");
  if (buf != NULL)
  {
    layer->component_id = (char *)calloc((strlen((const char *)buf)+1), \
                                          sizeof(char));
    strcpy(layer->component_id, (char *)buf);
  }
  xmlFree(buf);
  /*
   *  Get the component_idref of the layer
   */
  buf = xmlGetProp(xml_node_layer, (unsigned char*)"component_idref");
  if (buf != NULL)
  {
    layer->component_idref = (char *)calloc((strlen((const char *)buf)+1), \
                                             sizeof(char));
    strcpy(layer->component_idref, (char *)buf);
  }
  xmlFree(buf);
  /*
   *  Get the layer_idref of the layer
   */
  buf = xmlGetProp(xml_node_layer, (unsigned char*)"layer_idref");
  if (buf != NULL)
  {
    layer->layer_idref = (char *)calloc((strlen((const char *)buf)+1), \
                                        sizeof(char));
    strcpy(layer->layer_idref, (char *)buf);
  }
  xmlFree(buf);
  /*
   *  Get the layer_id of the layer
   */
  buf = xmlGetProp(xml_node_layer, (unsigned char*)"layer_id");
  if (buf != NULL)
  {
    layer->layer_id = (char *)calloc((strlen((const char *)buf)+1), \
                                      sizeof(char));
    strcpy(layer->layer_id, (char *)buf);
  }
  xmlFree(buf);
  /*  
   * ----------------------------------------------------------------
   */
  xml_node = xml_node_layer->xmlChildrenNode;
  while (xml_node != NULL) 
  {
    /*---------------------------------------------------------------
     *  General layer information
     */
    /* 
     * Extract the layer component type. This overwrites the layer->type, 
     * but should it?
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"type")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if (strncmp((char *)buf,"gaussian",8)==0) 
        layer->type = LAYER_GAUSSIAN;
      else if (strncmp((char *)buf,"box",3)==0) 
        layer->type = LAYER_BOX;
      else if (strncmp((char *)buf,"function",8)==0) 
        layer->type = LAYER_FUNCTION;
      else yanera_error("Incorrect <layer/> <type/>", \
                         yanera->filename, xml_node->line, yanera);
      xmlFree(buf);
    }
    /* 
     * Extract the layer name.
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"name")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      layer->name = (char *)calloc((strlen((const char *)buf)+1),sizeof(char));
      strcpy(layer->name, (char *)buf);
      xmlFree(buf);
    }
    /*---------------------------------------------------------------
     *  Information regarding function type layers
     */
    /* 
     * Extract the layer function.
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"func")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      layer->func = (char *)calloc((strlen((const char *)buf)+1),sizeof(char));
      strcpy(layer->func, (char *)buf);
      xmlFree(buf);
    }
    /*---------------------------------------------------------------
     *  All adjustable paramters
     */
    /* 
     * Extract the layer function parameters
     * d1 is the value
     * c1 is the name (eg. 'a', 'b', etc.)
     * i1 is the fix property
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"parm")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&d1);
      if (i2!=1) 
      {
        yanera_error("Can't read <parm/>", yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
      
      buf = xmlGetProp(xml_node, (unsigned char*)"fix");
      i1 = getYesNoBooleanFromString((char *)buf);
      if (i1 == ERROR) 
      {
        yanera_error("Can't read <parm/> fix property", \
                     yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
      
      buf = xmlGetProp(xml_node, (unsigned char*)"name");
      i2=sscanf((char *)buf,"%c",&c1);
      if (i2!=1) 
      {
        yanera_error("Can't read <parm/> name property", \
                      yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
      
      i2 = newFuncParameter(c1, d1, i1, layer, yanera);
      
      /* ---- */
      parseMinMax(xml_doc,xml_node,i2,yanera);
    }
    /* 
     * Extract the layer thickness
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"thik")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
      { 
        layer->thik = -2;
        xmlFree(buf);
      }
      else
      {
        i2=sscanf((char *)buf, "%lf", &d1);
        if (i2!=1) 
        {
          yanera_error("Can't read <thik/>", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
      
        buf = xmlGetProp(xml_node, (unsigned char*)"fix");
        i1 = getYesNoBooleanFromString((char *)buf);
        if (i1 == ERROR)
        {
          yanera_error("Can't read <thik/> fix", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
        
        layer->thik = newParameter(d1, i1, yanera);
        
        /* ---- */
        parseMinMax(xml_doc,xml_node,layer->thik,yanera);
      }
    }
    /* 
     * Extract the layer roughness
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"sigz")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
      { 
        layer->sigz = -2;
        xmlFree(buf);
      }
      else
      {
        i2=sscanf((char *)buf, "%lf", &d1);
        if (i2!=1)
        {
          yanera_error("Can't read <sigz/>", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
      
        buf = xmlGetProp(xml_node, (unsigned char*)"fix");
        i1 = getYesNoBooleanFromString((char *)buf);
        if (i1 == ERROR) 
        {
          yanera_error("Can't read <sigz/> fix", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
        
        layer->sigz = newParameter(d1, i1, yanera);
        
        /* ---- */
        parseMinMax(xml_doc,xml_node,layer->sigz,yanera);
      }
    }
    /* 
     * Extract the layer center
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"cntr")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
      { 
        layer->cntr = -2;
        xmlFree(buf);
      }
      else
      {
        i2=sscanf((char *)buf,"%lf",&d1);
        if (i2!=1)
        {
          yanera_error("Can't read <cntr/>", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
      
        buf = xmlGetProp(xml_node, (unsigned char*)"fix");
        i1 = getYesNoBooleanFromString((char *)buf);
        if (i1 == ERROR)
        {
          yanera_error("Can't read <cntr/> fix", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
        
        layer->cntr = newParameter(d1, i1, yanera);
        
        /* ---- */
        parseMinMax(xml_doc,xml_node,layer->cntr,yanera);
      }
    }
    /* 
     * Extract the layer real sld
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"rsld")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
      { 
        layer->rsld = -2;
        xmlFree(buf);
      }
      else
      {
        i2=sscanf((char *)buf,"%lf",&d1);
        if (i2!=1)
        {
          yanera_error("Can't read <rsld/>", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
      
        buf = xmlGetProp(xml_node, (unsigned char*)"fix");
        i1 = getYesNoBooleanFromString((char *)buf);
        if (i1 == ERROR)
        {
          yanera_error("Can't read <rsld/> fix", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
        
        layer->rsld = newParameter(d1, i1, yanera);
        
        /* ---- */
        parseMinMax(xml_doc,xml_node,layer->rsld,yanera);
      }
    }
    /* 
     * Extract the layer imaginary sld
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"isld")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
      { 
        layer->isld = -2;
        xmlFree(buf);
      }
      else
      {
        i2=sscanf((char *)buf,"%lf",&d1);
        if (i2!=1)
        {
          yanera_error("Can't read <isld/>", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
      
        buf = xmlGetProp(xml_node, (unsigned char*)"fix");
        i1 = getYesNoBooleanFromString((char *)buf);
        if (i1 == ERROR)
        {
          yanera_error("Can't read <isld/> fix", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
        
        layer->isld = newParameter(d1, i1, yanera);
        
        /* ---- */
        parseMinMax(xml_doc,xml_node,layer->isld,yanera);
      }
    }
    /* 
     * Extract the layer real magnetic sld
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"rmag")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if ((!xmlStrcmp(buf, (const xmlChar *)"n/a")))
      { 
        layer->rmag = -2;
        xmlFree(buf);
      }
      else
      {
        i2=sscanf((char *)buf,"%lf",&d1);
        if (i2!=1)
        {
          yanera_error("Can't read <rmag/>", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
      
        buf = xmlGetProp(xml_node, (unsigned char*)"fix");
        i1 = getYesNoBooleanFromString((char *)buf);
        if (i1 == ERROR)
        {
          yanera_error("Can't read <rmag/> fix", yanera->filename, xml_node->line, yanera);
        }
        xmlFree(buf);
        
        layer->rmag = newParameter(d1, i1, yanera);
        
        /* ---- */
        parseMinMax(xml_doc,xml_node,layer->rmag,yanera);
      }
    }
    /*---------------------------------------------------------------
     *  Additional information flags
     */
    /* 
     * Extract the layer include flag
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"include")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if (strncmp((char *)buf, "yes", 3)==0) 
        layer->include_flag = YES;
      else if (strncmp((char *)buf, "no", 2)==0) 
        layer->include_flag = NO;
      else 
      {
        yanera_error("Incorrect <include/>", yanera->filename, xml_node->line, yanera);
      }
      xmlFree(buf);
    }
    
    /* Go to the next child of the layer */   
    xml_node = xml_node->next;
  }

  return;
}
/*============================================================================*/
void parseRepeat(xmlDocPtr xml_doc, xmlNodePtr xml_node_parent, \
                 unsigned short repeat_number, \
                 yanera_model *model, yanera_container *yanera) 
{
  xmlNodePtr     xml_node;
  yanera_layer  *layer, *layer_copy, *ptr1, *ptr2;
  yanera_model   temporary_model;
  unsigned short i1;
  
  /*
   * Make a temporary model for holding the group of repeating layers.
   */
  temporary_model.data_idref   = NULL;
  temporary_model.name         = NULL;
  temporary_model.background   = -1;
  temporary_model.polarized    = POLARIZED_NONE;
  temporary_model.first_layer  = NULL;
  temporary_model.last_layer   = NULL;
  temporary_model.slabs.number_of_slab_edges = 0;
  temporary_model.slabs.number_of_slabs      = 0;

  for (i1=0; i1<USHRT_MAX; i1++)
  {
    temporary_model.slabs.zpos[i1] = 0.0;
    temporary_model.slabs.thik[i1] = 0.0;
    temporary_model.slabs.rsld[i1] = 0.0;
  }
  
  /*
   * Loop through the child nodes of <repeat/>
   */
  xml_node = xml_node_parent->xmlChildrenNode;
  while (xml_node != NULL)
  {
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"layer")))
    {
      /* 
       * Add new layers into the model, as usual.
       */ 
      layer = newLayer(LAYER_REPEAT);
      linkLayerIntoModel(layer, model);
      parseLayer(xml_doc, xml_node, layer, yanera);
      /*
       * Normally repeat_flag = 0, but now we will use it, incrementing by 
       * one each time the group of layers is repeated.
       */
      layer->repeat_flag = 1;
      /*
       * Also, make a copy of the layers.
       */
      layer_copy = copyLayer(layer);
      linkLayerIntoModel(layer_copy, &temporary_model);
    }
    xml_node = xml_node->next;
  }
  
  /*
   * Copy the repeating layers into the model the correct number of times.
   */
  for (i1 = 2; i1 <= repeat_number; i1++)
  {
    ptr1 = temporary_model.first_layer;
    while (ptr1 != NULL)
    {
      layer = copyLayer(ptr1);
      layer->repeat_flag = i1;
      linkLayerIntoModel(layer, model);

      ptr1 = ptr1->next;
    }
  }
  
  /*
   * Free the memory used by the repeating copy.
   */
  ptr1 = temporary_model.first_layer;
  while (ptr1 != NULL)
  {
    free(ptr1->name);
    free(ptr1->layer_id);
    free(ptr1->layer_idref);
    free(ptr1->component_id);
    free(ptr1->component_idref);
    free(ptr1->func);
    free(ptr1->parm_names);
    free(ptr1->parm_values);
    
    ptr2 = ptr1;
    ptr1 = ptr1->next;
    free(ptr2);
  };
  
  return;
}
/*============================================================================*/
void parseDataSection(xmlDocPtr xml_doc, xmlNodePtr xml_node_parent, \
                          yanera_container *yanera) 
{
  xmlNodePtr        xml_node;
  xmlChar          *buf;
  
  xml_node = xml_node_parent->xmlChildrenNode;
  while (xml_node != NULL)
  {
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"data")))
    {
      /*
       *  Get the data_id of the data
       */
      buf = xmlGetProp(xml_node, (unsigned char*)"data_id");
      yanera->data[yanera->number_of_data].data_id = \
             (char *)calloc((strlen((const char *)buf)+1), sizeof(char));
      strcpy(yanera->data[yanera->number_of_data].data_id, (char *)buf);
      xmlFree(buf);
      /*
       * Create a new yanera_data
       */ 
      parseData(xml_doc, xml_node, &yanera->data[yanera->number_of_data]);
      yanera->number_of_data += 1;
    }
    
    xml_node = xml_node->next;
  } 
  return;
}
/*============================================================================*/
void parseData(xmlDocPtr xml_doc, xmlNodePtr xml_node_parent, \
               yanera_data *data) 
{
  xmlNodePtr   xml_node;
  xmlChar     *buf;
  
  xml_node = xml_node_parent->xmlChildrenNode;
  while (xml_node != NULL)
  {
    /*
     * <file_name>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"file_name")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      data->file_name = (char *)calloc((strlen((const char *)buf)+1), \
                                       sizeof(char));
      strcpy(data->file_name, (char *)buf);
      xmlFree(buf);     
    }
    /*
     * <resolution>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"resolution")))
    {
      parseResolution(xml_doc, xml_node, data);
    }
    
    xml_node = xml_node->next;
  }
  return;
}
/*============================================================================*/
void parseResolution(xmlDocPtr xml_doc, xmlNodePtr xml_node_data, \
                     yanera_data *data) 
{
  xmlNodePtr     xml_node;
  xmlChar       *buf;
  short          i1;
  
  buf = NULL;
  xml_node = xml_node_data->xmlChildrenNode;
  while (xml_node != NULL)
  {
    /*
     * Read the resolution type.
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"type")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if      (strncmp((char *)buf,"RESOLUTION_NONE", 15)==0) 
        data->resolution.type = RESOLUTION_NONE;
      else if (strncmp((char *)buf,"RESOLUTION_CONSTANT", 19)==0) 
        data->resolution.type = RESOLUTION_CONSTANT;
      else if (strncmp((char *)buf,"RESOLUTION_RELATIVE", 19)==0) 
        data->resolution.type = RESOLUTION_RELATIVE;
      else if (strncmp((char *)buf,"RESOLUTION_ARRAY_CONSTANT", 25)==0) 
        data->resolution.type = RESOLUTION_ARRAY_CONSTANT;
      else if (strncmp((char *)buf,"RESOLUTION_ARRAY_RELATIVE", 25)==0) 
        data->resolution.type = RESOLUTION_ARRAY_RELATIVE;
      else 
      {
        yanera_error("Incorrect <resolution/> <type/>", \
                      __FILE__, __LINE__, NULL);
      }
      xmlFree(buf); buf = NULL;
    }
    /*
     * Read the resolution value. If present then there will be only one value.
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"value")))
    {
      if (data->resolution.n > 0) 
      { 
        yanera_error("Is resolution a single value or an array?", \
                     __FILE__, __LINE__, NULL);
      }
      if (xml_node->xmlChildrenNode != NULL)
      {
        data->resolution.value = (double *)malloc(sizeof(double));
        buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
        i1=sscanf((const char *)buf,"%lf",&data->resolution.value[0]);
        if (i1!=1) 
        {
          yanera_error("Can't read <resolution/> <value/>", \
                       __FILE__, __LINE__, NULL);
        }
        data->resolution.n = 1;
      }
      xmlFree(buf); buf = NULL;
    }
    /*
     * Read the resolution array file_name.
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"file_name")))
    {
      if (xml_node->xmlChildrenNode != NULL)
      {
        buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
        data->resolution.file_name = \
             (char *)calloc((strlen((const char *)buf)+1), sizeof(char));
        strcpy(data->resolution.file_name, (char *)buf);
        xmlFree(buf); buf = NULL;
      }
    } 
    xml_node = xml_node->next;
  }
  
  return; 
}
/*============================================================================*/
void parseMiscellaneousSection(xmlDocPtr xml_doc, xmlNodePtr xml_parent_node, \
                               yanera_container *yanera) 
{
  unsigned int i2;
  xmlNodePtr     xml_node;
  xmlChar       *buf;
  
  xml_node = xml_parent_node->xmlChildrenNode;
  while (xml_node != NULL)
  {
    /*
     * <write_results>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"write_results")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      yanera->misc.write_results = getYesNoBooleanFromString((char *)buf);
      if (yanera->misc.write_results == ERROR)
      {
        yanera_error("Can't read <write_results/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <write_profile>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"write_profile")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      yanera->misc.write_profile = getYesNoBooleanFromString((char *)buf);
      if (yanera->misc.write_profile == ERROR) 
      {
        yanera_error("Can't read <write_profile/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <write_reflectivity>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"write_reflectivity")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      yanera->misc.write_reflectivity = getYesNoBooleanFromString((char *)buf);
      if (yanera->misc.write_reflectivity == ERROR) 
      {
        yanera_error("Can't read <write_reflectivity/>", \
                     __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <write_slabs>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"write_slabs")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      yanera->misc.write_slabs = getYesNoBooleanFromString((char *)buf);
      if (yanera->misc.write_slabs == ERROR)
      {
        yanera_error("Can't read <write_slabs/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <q_min>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"q_min")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&yanera->misc.q_min);
      if (i2!=1)
      {
        yanera_error("Can't read <q_min/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <q_max>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"q_max")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&yanera->misc.q_max);
      if (i2!=1)
      {
        yanera_error("Can't read <q_max/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <q_num>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"q_num")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%hd",&yanera->misc.q_num);
      if (i2!=1)
      {
        yanera_error("Can't read <q_num/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <z_num>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"z_num")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%hd",&yanera->misc.z_num);
      if (i2!=1)
      {
        yanera_error("Can't read <z_num/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <quadrature_error>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"quadrature_error")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&yanera->misc.quadrature_error);
      if (i2!=1)
      {
        yanera_error("Can't read <quadrature_error/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <quadrature_thik>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"quadrature_thik")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&yanera->misc.quadrature_thik);
      if (i2!=1)
      {
        yanera_error("Can't read <quadrature_thik/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }   
    /*
     * <fit_do>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"fit_do")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      yanera->misc.fit_do = getYesNoBooleanFromString((char *)buf);
      if (yanera->misc.fit_do == ERROR)
      {
        yanera_error("Can't read <fit_do/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <fit_weighting>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"fit_weighting")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if (strncmp((char *)buf,"WEIGHT_NONE",11)==0) 
        yanera->misc.fit_weighting = WEIGHT_NONE;
      else if (strncmp((char *)buf,"WEIGHT_R",8)==0) 
        yanera->misc.fit_weighting = WEIGHT_R;
      else if (strncmp((char *)buf,"WEIGHT_SQRT",11)==0) 
        yanera->misc.fit_weighting = WEIGHT_SQRT;
      else if (strncmp((char *)buf,"WEIGHT_DATA",11)==0) 
        yanera->misc.fit_weighting = WEIGHT_DATA;
      else 
      {
        yanera_error("Can't read <fit_weighting/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <fit_iterations>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"fit_iterations")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%hd",&yanera->misc.fit_iterations);
      if (i2!=1)
      {
        yanera_error("Can't read <fit_iterations/>", \
                     __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <fit_write_iterations>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"fit_write_iterations")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%hd",&yanera->misc.fit_write_iterations);
      if (i2!=1)
      {
        yanera_error("Can't read <fit_write_iterations/>", \
                     __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    /*
     * <fit_method>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"fit_method")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      if      (strncmp((char *)buf,"CONJUGATE_FR",12)==0) 
      {  
        yanera->misc.fit_method = CONJUGATE_FR;
        yanera->misc.fit_method_mdmin = gsl_multimin_fdfminimizer_conjugate_fr;
      }
      else if (strncmp((char *)buf,"CONJUGATE_PR",12)==0)
      {
        yanera->misc.fit_method = CONJUGATE_PR;
        yanera->misc.fit_method_mdmin = gsl_multimin_fdfminimizer_conjugate_pr;
      }
      else if (strncmp((char *)buf,"VECTOR_BFGS",11)==0)
      {
        yanera->misc.fit_method = VECTOR_BFGS;
        yanera->misc.fit_method_mdmin = gsl_multimin_fdfminimizer_vector_bfgs;
      }
      else if (strncmp((char *)buf,"STEEP_DESC",10)==0)
      {
        yanera->misc.fit_method = STEEP_DESC;
        yanera->misc.fit_method_mdmin = \
                                    gsl_multimin_fdfminimizer_steepest_descent;
      }
      else if (strncmp((char *)buf,"NMSIMPLEX",10)==0)
      {
        yanera->misc.fit_method = NMSIMPLEX;
        yanera->misc.fit_method_mdmin_simplex = \
                                    gsl_multimin_fminimizer_nmsimplex;
      }
      else if (strncmp((char *)buf,"SIMAN",5)==0)
      {
        yanera->misc.fit_method = SIMAN;
      }
      else if (strncmp((char *)buf,"LMSDR",5)==0)
      {
        yanera->misc.fit_method = LMSDR;
        yanera->misc.fit_method_lstsq = gsl_multifit_fdfsolver_lmsder;
      }
      else if (strncmp((char *)buf,"LMDR",4)==0)
      {
        yanera->misc.fit_method = LMDR;
        yanera->misc.fit_method_lstsq = gsl_multifit_fdfsolver_lmder;
      }
#ifdef HAVE_OOL
      else if (strncmp((char *)buf,"OOL_SPG",7)==0)
      {  
        yanera->misc.fit_method = OOL_SPG;
        yanera->misc.fit_method_ool = ool_conmin_minimizer_spg;
      }
      else if (strncmp((char *)buf,"OOL_GENCAN",10)==0)
      {
        yanera->misc.fit_method = OOL_GENCAN;
        yanera->misc.fit_method_ool = ool_conmin_minimizer_gencan;
      }
#endif
      else if (strncmp((char *)buf,"CLMSDR",17)==0)
      {
        yanera->misc.fit_method = CLMSDR;
        yanera->misc.fit_method_lstsq = gsl_multifit_fdfsolver_lmsder;
      }
      else if (strncmp((char *)buf,"CLMDR",16)==0)
      {
        yanera->misc.fit_method = CLMDR;
        yanera->misc.fit_method_lstsq = gsl_multifit_fdfsolver_lmder;
      }
#ifdef HAVE_LEVMAR
      else if (strncmp((char *)buf,"LEVMAR",6)==0)
      {
        yanera->misc.fit_method = LEVMAR;
      }
#endif
      else
      {
        yanera_error("Can't read <fit_method/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
    }
    xml_node = xml_node->next;
  } 
  return;
}
/*============================================================================*/
void parseMinMax(xmlDocPtr xml_doc, xmlNodePtr xml_node_parent, \
                 unsigned short parm_index, yanera_container *yanera)
{  
  unsigned int   i2;
  xmlNodePtr     xml_node;
  xmlChar       *buf;
  

  xml_node = xml_node_parent->xmlChildrenNode;
  while (xml_node != NULL)
  {
    /*
     * <max>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"max")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&yanera->parameters.max[parm_index]);
      if (i2!=1)
      {
        yanera_error("Can't read <max/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
      if (yanera->parameters.con[parm_index] == CONSTRAIN_MIN)
      {
        yanera->parameters.con[parm_index] = CONSTRAIN_BOTH;
      }
      else
      {
        yanera->parameters.con[parm_index] = CONSTRAIN_MAX;
      }
    }
    /*
     * <min>
     */
    if ((!xmlStrcmp(xml_node->name, (const xmlChar *)"min")))
    {
      buf = xmlNodeListGetString(xml_doc, xml_node->xmlChildrenNode, 1);
      i2=sscanf((char *)buf,"%lf",&yanera->parameters.min[parm_index]);
      if (i2!=1)
      {
        yanera_error("Can't read <min/>", __FILE__, __LINE__, yanera);
      }
      xmlFree(buf);
      if (yanera->parameters.con[parm_index] == CONSTRAIN_MAX)
      {
        yanera->parameters.con[parm_index] = CONSTRAIN_BOTH;
      }
      else
      {
        yanera->parameters.con[parm_index] = CONSTRAIN_MIN;
      }
    }
    xml_node = xml_node->next;
  } 
  return;
}

---