yanera_xml_util.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_util.h"
#include "yanera_util.h"
#include "yanera_postfix.h"
/*=========================================================================*/
void linkComponentIntoContainer(yanera_layer *layer, yanera_container *yanera)
{
  yanera_layer *l;
  /*
   * Any error checking to be done?
   */

  /* 
   * link-in the layer as the last component 
   */
  if (yanera->components == NULL)
  {
    yanera->components = layer;
  }
  else
  {
    l = yanera->components;
    while (l->next != NULL) {
      l = l->next;
    };
    l->next = layer;
  }
  
  return;
}
/*============================================================================*/
short newParameter(double d, short i, yanera_container *yanera)
{
  /*
   * Increase the size of the parameter and fix arrays by one,
   * and add the values passed into the funciton.
   */
  yanera->parameters.p   = realloc(yanera->parameters.p, \
      (yanera->parameters.n+1)*sizeof(double));
  yanera->parameters.f   = realloc(yanera->parameters.f, \
      (yanera->parameters.n+1)*sizeof(unsigned short));
  yanera->parameters.tmp = realloc(yanera->parameters.tmp, \
      (yanera->parameters.n+1)*sizeof(double));
  yanera->parameters.min = realloc(yanera->parameters.min, \
      (yanera->parameters.n+1)*sizeof(double));
  yanera->parameters.max = realloc(yanera->parameters.max, \
      (yanera->parameters.n+1)*sizeof(double));
  yanera->parameters.con = realloc(yanera->parameters.con, \
      (yanera->parameters.n+1)*sizeof(double));
           
  yanera->parameters.p[yanera->parameters.n] = d;
  yanera->parameters.f[yanera->parameters.n] = i;
  yanera->parameters.tmp[yanera->parameters.n] = 0.0;
  
  yanera->parameters.min[yanera->parameters.n] = -10*fabs(d);
  yanera->parameters.max[yanera->parameters.n] =  10*fabs(d);
  yanera->parameters.con[yanera->parameters.n] = CONSTRAIN_NONE;
  
  yanera->parameters.n += 1;
  
  /*
   * Return the array index value of the newly added paramter.
   */
  return (yanera->parameters.n - 1);
}

/*============================================================================*/
short newFuncParameter(char c, double d, unsigned short i, \
                       yanera_layer *layer, yanera_container *yanera)
{
  /*
   * Add the paramater variable to the list of variables.
   */
  layer->parm_names = realloc(layer->parm_names, \
                             (layer->number_of_parm+1)*sizeof(char));
  layer->parm_values= realloc(layer->parm_values, \
                             (layer->number_of_parm+1)*sizeof(short));
  layer->parm_names[layer->number_of_parm] = c;
  /*
   * Add the actual numerical value to the paramter array.
   */
  layer->parm_values[layer->number_of_parm] = newParameter(d, i, yanera);
  layer->number_of_parm += 1;
      
  return layer->parm_values[layer->number_of_parm-1];
}
/*============================================================================*/
unsigned short getYesNoBooleanFromString(char *buf)
{
  short i1;
  
  i1 = strncmp(buf, "YES", 3);
  if (i1 == 0) return YES;
  else
  {
    i1 = strncmp(buf, "NO", 2);
    if (i1 == 0) return NO;
  }
  i1 = strncmp(buf, "yes", 3);
  if (i1 == 0) return YES;
  else
  {
    i1 = strncmp(buf, "no", 2);
    if (i1 == 0) return NO;
  }
  return ERROR;
}
/*============================================================================*/
void setYesNoBooleanFromString(char *buf, short i1)
{
  if (i1 == YES) sprintf((char *)buf, "YES");
  else  sprintf((char *)buf, "NO");
  return;
}
/*=========================================================================*/
yanera_layer *newLayer(short type)
{
  yanera_layer *layer = NULL;
  
  /*
   * Any error checking to be done?
   */
  
  /* 
   * Allocate a new layer
   */
  layer = (yanera_layer *)malloc(sizeof(yanera_layer));
  if (layer == NULL) 
  {
    yanera_error("No memory for a new layer.", __FILE__, __LINE__, NULL);
  }
  layer->layer_id        = NULL;
  layer->layer_idref     = NULL;
  layer->component_id    = NULL;
  layer->component_idref = NULL;
  layer->type            = type;
  layer->name            = NULL;
  layer->func            = NULL;
  layer->func_postfix    = NULL;
  layer->parm_names      = NULL;
  layer->parm_values     = NULL;
  layer->number_of_parm  = 0;
  layer->thik            = -1;
  layer->sigz            = -1;
  layer->cntr            = -1;
  layer->rsld            = -1;
  layer->isld            = -1;
  layer->rmag            = -1;
  layer->include_flag    = YES;
  layer->repeat_flag     = 0;
  layer->polarized       = POLARIZED_NONE;
  layer->prev            = NULL;
  layer->next            = NULL;
  
  return layer;
}
/*=========================================================================*/
yanera_layer *copyLayer(yanera_layer *source)
{
  yanera_layer *new;
  yanera_postfix_queue_element *pfqe;

  new = newLayer(LAYER_LAYER);
  /*-----------------------------------
   * ID's and IDREF's
   */
  if (source->layer_id != NULL)
  {
    new->layer_id = (char *)calloc((strlen(source->layer_id)+1),sizeof(char));
    strcpy(new->layer_id, source->layer_id);
  }
  else new->layer_id = NULL;
  if (source->layer_idref != NULL)
  {
    new->layer_idref = (char *)calloc((strlen(source->layer_idref)+1), \
                                      sizeof(char));
    strcpy(new->layer_idref, source->layer_idref);
  }
  else new->layer_idref = NULL;
  if (source->component_id != NULL)
  {
    new->component_id = (char *)calloc((strlen(source->component_id)+1), \
                                   sizeof(char));
    strcpy(new->component_id, source->component_id);
  }
  else new->component_id = NULL;
  if (source->component_idref != NULL)
  {
    new->component_idref = (char *)calloc((strlen(source->component_idref)+1), \
                                   sizeof(char));
    strcpy(new->component_idref, source->component_idref);
  }
  else new->component_idref = NULL;
  /*-----------------------------------
   * General layer information
   */
  new->type = source->type;
  if (source->name != NULL)
  {
    new->name = (char *)calloc((strlen(source->name)+1),sizeof(char));
    strcpy(new->name, source->name);
  }
  else new->name = NULL;
  /*-----------------------------------
   * Information regarding function type layers
   */
  if (source->func != NULL)
  {
    new->func = (char *)calloc((strlen(source->func)+1),sizeof(char));
    strcpy(new->func, source->func);
  }
  else new->func = NULL;
  if (source->parm_names != NULL)
  {
    new->parm_names = (char *)calloc((source->number_of_parm+1),sizeof(char));
    strncpy(new->parm_names, source->parm_names, source->number_of_parm);
  }
  else new->parm_names = NULL;
  new->number_of_parm = source->number_of_parm;
  if (source->func_postfix != NULL)
  {
    new->func_postfix = initizlize_postfix_queue();
    pfqe = source->func_postfix->front;
    while (pfqe != NULL)
    {
      enqueue_postfix_queue(new->func_postfix, \
                            pfqe->oper, pfqe->numb, pfqe->indx, pfqe->type);
      pfqe = pfqe->next;
    }
  }
  /*-----------------------------------
   * All adjustable paramters
   */
  if (source->parm_values != NULL)
  {
    new->parm_values = (short *)calloc((source->number_of_parm+1), \
                                        sizeof(short));
    memcpy(new->parm_values, source->parm_values,\
          (source->number_of_parm*sizeof(short)));
  }
  else new->parm_values = NULL;
  new->thik = source->thik;
  new->sigz = source->sigz;
  new->cntr = source->cntr;
  new->rsld = source->rsld;
  new->isld = source->isld;
  new->rmag = source->rmag;
  /*-----------------------------------
   * Additional information flags
   */
  new->include_flag = source->include_flag;
  new->repeat_flag  = source->repeat_flag;
  new->polarized    = source->polarized;
  new->prev = NULL;
  new->next = NULL;
  
  return new;
}
/*============================================================================*/
void linkLayerIntoModel(yanera_layer *layer, yanera_model *model)
{
  /*
   * Any error checking to be done?
   */
    
  /* 
   * link-in the layer 
   */
  if (model->first_layer == NULL)
  {
    model->first_layer = layer;
    model->last_layer  = layer;
  }
  else
  {
    model->last_layer->next = layer;
    layer->prev             = model->last_layer;
    model->last_layer       = layer;
  }
  
  return;
}
/*============================================================================*/
void  xmlErrorFunc(void *ctx, xmlErrorPtr error)
{
  fprintf(stderr,"XML error      : %s", error->message);
  fprintf(stderr,"   In file     : %s\n", error->file);
  fprintf(stderr,"   At line     : %d\n", error->line);
  return;
}

---