yanera_model_build.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_model_build.h"
#include "yanera_xml_util.h"
#include "yanera_postfix.h"
/*============================================================================*/
void yanera_complete_models(yanera_container *yanera)
{
  short i;
  yanera_layer *component_pointer, *layer;
  
  /*
   *  Polarization was idicated at the model level.
   *  Copy the polarization value to thoses layers in the models
   *  that have non-zero magnetic SLD.
   */
  for (i=0; i<yanera->number_of_models; i++)
  {
    layer = yanera->models_xml[i].first_layer;
    while (layer != NULL)
    {
      if (layer->rmag > -1) 
      { layer->polarized = yanera->models_complete[i].polarized; }
      layer = layer->next;
    }
  }
  
  /*
   * 1. Make copies of the basic model to form the basis of each 
   *    complete model.
   * 2. Modify all the complete models by their differences
   */
  for (i=0; i<yanera->number_of_models; i++)
  {
    copyModel(&yanera->models_complete[i], &yanera->models_xml[0]);
    modifyModel(&yanera->models_complete[i], &yanera->models_xml[i]);
  }
  
  /*
   * Modify all the complete models by any components
   */
  component_pointer = yanera->components;
  while (component_pointer != NULL)
  {
    for (i=0; i<yanera->number_of_models; i++)
    {
      modifyComponents(&yanera->models_complete[i], component_pointer);
    }
    component_pointer = component_pointer->next;
  }
  
  /*
   * For functions, complete the conversion form infix to postfix expression.
   */
  if (yanera->type == MODEL_FUNCTION)
  {
    for (i=0; i<yanera->number_of_models; i++)
    {
      layer = yanera->models_complete[i].first_layer;
      while (layer != NULL)
      {
        if (layer->type == LAYER_FUNCTION)
        {
          layer->func_postfix = initizlize_postfix_queue();
          parse_expression(layer->func_postfix, layer->func, \
                           layer->parm_names, layer->parm_values);
        }
        layer = layer->next;
      }
    }
  }
    
  return;
}
/*============================================================================*/
void copyModel(yanera_model *destination, yanera_model *source)
{
  yanera_layer *layer, *layer_pointer;
  /*
   * Make a copy of IDREF's
   */
  if (source->data_idref != NULL)
  {
    destination->data_idref = (char *)calloc((strlen(source->data_idref)+1), \
                                      sizeof(char));
    strcpy(destination->data_idref, source->data_idref);
  }
  else destination->data_idref = NULL;
  /*
   * General information and <model/> level paramters
   */
  if (source->name != NULL)
  {
    destination->name = (char *)calloc((strlen(source->name)+1), \
                                     sizeof(char));
    strcpy(destination->name, source->name);
  }
  else destination->name= NULL;
  destination->background = source->background;
  destination->polarized  = source->polarized;
  /*
   * Make a copy of the layers
   */
  layer_pointer = source->first_layer;
  while (layer_pointer != NULL)
  {
    layer = copyLayer(layer_pointer);
    linkLayerIntoModel(layer, destination);
    layer_pointer = layer_pointer->next;
  }
  /*
   * Don't copy slabs. No point.
   */
  return;
}
/*============================================================================*/
void modifyModel(yanera_model *destination, yanera_model *source)
{
  yanera_layer *source_layer;
  yanera_layer *destination_layer, *ptr;
  enum boolean   found;
  short          i1, i2;
  
  /*
   * Modify those part of <model/> not related to layers.
   */
  if (source->data_idref != NULL)
  {
    free(destination->data_idref);
    destination->data_idref = (char *)calloc((strlen(source->data_idref)+1), \
                                     sizeof(char));
    strcpy(destination->data_idref, source->data_idref);
  }
  if (source->name != NULL)
  {
    free(destination->name);
    destination->name = (char *)calloc((strlen(source->name)+1), \
                                     sizeof(char));
    strcpy(destination->name, source->name);
  }
  if (source->background > -1) destination->background = source->background;
  if (source->polarized  != POLARIZED_NONE)
  {
    destination->polarized  = source->polarized;
    /*
     * Flip the polarization of all layers with nonzero rmag.
     */
    destination_layer = destination->first_layer;
    while (destination_layer != NULL)
    {
      if (destination_layer->rmag > -1)
      {
        destination_layer->polarized  = source->polarized;
      }
      destination_layer = destination_layer->next;
    }
  }
  /*
   * Modify the layers.
   */  
  source_layer = source->first_layer;
  while (source_layer != NULL)
  {
    destination_layer = destination->first_layer;
    while (destination_layer != NULL)
    {
      /*===============================================================
       * Find layer in destination model with same layer_id as source layer.
       */
      found = NO;
      if ((source_layer->layer_idref != NULL) && \
          (destination_layer->layer_id != NULL))
      {
        if (strcmp(source_layer->layer_idref, \
                     destination_layer->layer_id) == 0)
        {
          found = YES;
        }
      }
      /*===============================================================*/
      
      /*===============================================================
       * If found, modify the destination layer by the source.
       */
      if (found == YES)
      {
        if (source_layer->component_idref != NULL)
        {
          free(destination_layer->component_idref);
          destination_layer->component_idref=(char *)calloc(\
                      (strlen(source_layer->component_idref)+1),sizeof(char));
          strcpy(destination_layer->component_idref, \
                 source_layer->component_idref);
        }
        if (source_layer->type > LAYER_LAYER) 
        { destination_layer->type = source_layer->type; }
        if (source_layer->name != NULL)
        {
          free(destination_layer->name);
          destination_layer->name=(char *)calloc(\
                                  (strlen(source_layer->name)+1),sizeof(char));
          strcpy(destination_layer->name, source_layer->name);
        }
        if (source_layer->func != NULL)
        {
          free(destination_layer->func);
          destination_layer->func=(char *)calloc(\
                                  (strlen(source_layer->func)+1),sizeof(char));
          strcpy(destination_layer->func, source_layer->func);
        }
        if ((source_layer->parm_names != NULL) && \
            (source_layer->parm_values != NULL))
        {
          for(i1 = 0; i1 < source_layer->number_of_parm; i1++)
          {
            for (i2 = 0; i2 < destination_layer->number_of_parm; i2++)
            {
              if (source_layer->parm_names[i1] == \
                  destination_layer->parm_names[i2])
              {
                destination_layer->parm_values[i2] = \
                     source_layer->parm_values[i1];
              }
            }
          }
        }
        if (source_layer->thik > -1) 
          destination_layer->thik = source_layer->thik;
        if (source_layer->sigz > -1) 
          destination_layer->sigz = source_layer->sigz;
        if (source_layer->cntr > -1) 
          destination_layer->cntr = source_layer->cntr;
        if (source_layer->rsld > -1) 
          destination_layer->rsld = source_layer->rsld;
        if (source_layer->isld > -1) 
          destination_layer->isld = source_layer->isld;
        if (source_layer->rmag > -1) 
          destination_layer->rmag = source_layer->rmag;
        if (source_layer->repeat_flag > 0) 
          destination_layer->repeat_flag = source_layer->repeat_flag;
        
        /*
         *  Case for <include/> being 'no'. 
         *  Delink that layer from the destination/
         */
        if (source_layer->include_flag == NO)
        {
          ptr = destination->first_layer;
          while (ptr->next != destination_layer) ptr = ptr->next;
          ptr->next = destination_layer->next;
          free(destination_layer->layer_id);
          free(destination_layer->layer_idref);
          free(destination_layer->component_id);
          free(destination_layer->component_idref);
          free(destination_layer->name);
          free(destination_layer->func);
          free(destination_layer->parm_names);
          free(destination_layer->parm_values);
          free(destination_layer);
          destination_layer = ptr;
        }
      
      /*
       * Done with modifying this layer
       */
      }
      /*===============================================================*/
    
      /*===============================================================*/    
      /*
       * Move on to next layer in destination to test if it also has source id
       */
      destination_layer = destination_layer->next;
    }

    source_layer = source_layer->next;
  }
  

  return;
}
/*============================================================================*/
void modifyComponents(yanera_model *destination, yanera_layer *component)
{
  yanera_layer  *destination_layer;
  enum boolean   found;
  /*
   * Loop over the layers in the model
   */  
  destination_layer = destination->first_layer;
  while (destination_layer != NULL)
  {
    found = NO;
    /*
     * If the layer has a component_idref ...
     */
    if (destination_layer->component_idref != NULL)
    {
      /*
       * ... and if the that component_idref matches the id of the component.
       */
      if (strcmp(destination_layer->component_idref, \
                 component->component_id) == 0)
      {
        found = YES;
      }
    }
    
    /*
     * Modify the links by the component values.
     * Change only those things likely to be altered.
     */
    if (found == YES)
    {
      if (component->type > 0) destination_layer->type = component->type;
      if (component->name != NULL)
      {
        free(destination_layer->name);
        destination_layer->name=(char *)calloc((strlen(component->name)+1), \
                                            sizeof(char));
        strcpy(destination_layer->name, component->name);
      }
      if (component->thik > -1) destination_layer->thik = component->thik;
      if (component->sigz > -1) destination_layer->sigz = component->sigz;
      if (component->cntr > -1) destination_layer->cntr = component->cntr;
      if (component->rsld > -1) destination_layer->rsld = component->rsld;
      if (component->isld > -1) destination_layer->isld = component->isld;
      if (component->rmag > -1) destination_layer->rmag = component->rmag;
    }
    
    destination_layer = destination_layer->next;
  }
  return;
}

---