OOPSE/libBASS/Globals.cpp

#include <cstdlib>
#include <cstdio>
#include <cstring>

#include "Globals.hpp"
#include "simError.h"
#ifdef IS_MPI
#include "mpiBASS.h"
#endif // is_mpi

/*
 * The following section lists all of the defined tokens for the
 * gloabal assignment statements. All are prefixed with a G_ to avoid
 * stepping on any previously defined enumerations. 
 *
 * NOTE: tokens start at 1, 0 is a resrved token number
 */

//required parameters
#define G_FORCEFIELD  1
#define G_NCOMPONENTS 2
#define G_TARGETTEMP  3
#define G_ENSEMBLE    4
#define G_DT          5
#define G_RUNTIME     6

//optional parameters
#define G_INITIALCONFIG 7
#define G_FINALCONFIG   8
#define G_NMOL          9
#define G_DENSITY       10
#define G_BOX           11
#define G_BOXX          12
#define G_BOXY          13
#define G_BOXZ          14
#define G_SAMPLETIME    15
#define G_STATUSTIME    16
#define G_ECR           17
#define G_DIELECTRIC    18
#define G_TEMPSET       19
#define G_THERMALTIME   20
#define G_USEPBC        21
#define G_MIXINGRULE    22
#define G_EST           23
#define G_USERF         24
#define G_TARGETPRESSURE 25
#define G_QMASS         26
#define G_TAURELAX      27


Globals::Globals(){
  
  int i;
  
  components = NULL;
  
  command_table = new LinkedCommand*[hash_size];
  for( i=0; i<hash_size; i++ ) command_table[i] = NULL;

  addHash( "forceField",    G_FORCEFIELD );
  addHash( "nComponents",   G_NCOMPONENTS );
  addHash( "targetTemp",    G_TARGETTEMP );
  addHash( "ensemble",      G_ENSEMBLE );

  addHash( "dt",            G_DT );
  addHash( "runTime",       G_RUNTIME );

  addHash( "initialConfig", G_INITIALCONFIG );
  addHash( "finalConfig",   G_FINALCONFIG );
  addHash( "nMol",          G_NMOL );
  addHash( "density",       G_DENSITY );
  addHash( "box",           G_BOX );
  addHash( "boxX",          G_BOXX );
  addHash( "boxY",          G_BOXY );
  addHash( "boxZ",          G_BOXZ );
  addHash( "sampleTime",    G_SAMPLETIME );
  addHash( "statusTime",    G_STATUSTIME );
  addHash( "electrostaticCutoffRadius",            G_ECR );
  addHash( "dielectric",    G_DIELECTRIC );
  addHash( "tempSet",       G_TEMPSET );
  addHash( "thermalTime",   G_THERMALTIME );
  addHash( "mixingRule",    G_MIXINGRULE);
  addHash( "usePeriodicBoundaryConditions",        G_USEPBC);
  addHash( "electrostaticSkinThickness",           G_EST );
  addHash( "useReactionField",                     G_USERF );
  addHash( "targetPressure",                       G_TARGETPRESSURE);
  addHash( "qMass",                                G_QMASS);
  addHash( "tauRelax",                             G_TAURELAX);
  
  // define some default values 

  strcpy( mixingRule,"standard");  //default mixing rules to standard.
  usePBC = 1; //default  periodic boundry conditions to on
  useRF  = 0;
  
  have_force_field =  0;
  have_n_components = 0;
  have_target_temp =  0;
  have_ensemble =     0;
  have_dt =           0;
  have_run_time =     0;
  
  have_initial_config = 0;
  have_final_config =   0;
  have_n_mol =          0;
  have_density =        0;
  have_box =            0;
  have_box_x =          0;
  have_box_y =          0;
  have_box_y =          0;
  have_box_z =          0;
  have_sample_time =    0;
  have_status_time =    0;
  have_thermal_time =   0;
  have_ecr =            0;
  have_dielectric =     0;
  have_tempSet =        0;
  have_est =            0;
  have_target_pressure =0;
  have_q_mass =         0;
  have_tau_relax =      0;
 }

Globals::~Globals(){
  int i;

  for( i=0; i<hash_size; i++ ){
    if( command_table[i] != NULL ) delete command_table[i];
  }
  delete[] command_table;

  if( components != NULL ){
    for( i=0; i<n_components; i++ ) delete components[i];
    delete[] components;
  }
}

int Globals::newComponent( event* the_event ){
  
  current_component = new Component;
  int index = the_event->evt.blk_index;
  char err[200];
  
  if( have_n_components && index < n_components ) 
    components[index] = current_component;
  else{
    if( have_n_components ){
      sprintf( err, "Globals error, %d out of nComponents range", 
               index );
      the_event->err_msg = strdup( err );
      return 0;
    }
    else{
      the_event->err_msg = strdup("Globals error, nComponents not given before"
                                  "first component declaration." );
      return 0;
    }
  }  
 
  return 1;
}


int Globals::componentAssign( event* the_event ){

  switch( the_event->evt.asmt.asmt_type ){
    
  case STRING:
    return current_component->assignString( the_event->evt.asmt.lhs,
                                            the_event->evt.asmt.rhs.sval,
                                            &(the_event->err_msg));
    break;
    
  case DOUBLE:
    return current_component->assignDouble( the_event->evt.asmt.lhs,
                                            the_event->evt.asmt.rhs.dval,
                                            &(the_event->err_msg));
    break;
    
  case INT:
    return current_component->assignInt( the_event->evt.asmt.lhs,
                                         the_event->evt.asmt.rhs.ival,
                                         &(the_event->err_msg));
    break;
    
  default:
    the_event->err_msg = strdup( "Globals error. Invalid component"
                                 " assignment type" );
    return 0;
    break;
  }
  return 0;
}

int Globals::componentStartIndex( event* the_event ){

  current_component->startIndex( the_event->evt.si.array, 
                                 the_event->evt.si.n_elements );
  return 1;
}

int Globals::componentEnd( event* the_event ){

  the_event->err_msg = current_component->checkMe();
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int Globals::globalAssign( event* the_event ){
  
  int key;
  int token;
  interface_assign_type the_type =  the_event->evt.asmt.asmt_type;
  char* lhs = the_event->evt.asmt.lhs;
  char err[300];
  
  token = 0;
  key = hash( lhs );
  if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
  
  if( token ){
    
    switch( token ){
      
    case G_FORCEFIELD:
      if( the_type == STRING ){
        strcpy( force_field, the_event->evt.asmt.rhs.sval );
        have_force_field = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. forceField was not a string assignment.\n" );
      return 0;
      break;
      
    case G_NCOMPONENTS:
      if( the_type == STRING ){
        the_event->err_msg = 
          strdup("Global error. nComponents is not a double or an int.\n" );
        return 0;
      }
      
      else if( the_type == DOUBLE ){
        n_components = (int)the_event->evt.asmt.rhs.dval;
        components = new Component*[n_components];
        have_n_components = 1;
        return 1;
      }
      
      else{
        n_components = the_event->evt.asmt.rhs.ival;
        components = new Component*[n_components];
        have_n_components = 1;
        return 1;
      }
      break;
      
    case G_TARGETTEMP:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. targetTemp is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        target_temp = the_event->evt.asmt.rhs.dval;
        have_target_temp = 1;
        return 1;
        break;
        
      case INT:
        target_temp = (double)the_event->evt.asmt.rhs.ival;
        have_target_temp = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. targetTemp unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_ENSEMBLE:
      if( the_type == STRING ){
        strcpy( ensemble, the_event->evt.asmt.rhs.sval );
        have_ensemble = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. ensemble was not assigned to a string\n" );
      return 0;
      break;      

    case G_MIXINGRULE:
      if( the_type == STRING ){
        strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. mixing rule was not assigned to a string\n" );
      return 0;
      break;      
      
    case G_DT:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. dt is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        dt = the_event->evt.asmt.rhs.dval;
        have_dt = 1;
        return 1;
        break;
        
      case INT:
        dt = (double)the_event->evt.asmt.rhs.ival;
        have_dt = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. dt unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_RUNTIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. runTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        run_time = the_event->evt.asmt.rhs.dval;
        have_run_time = 1;
        return 1;
        break;
        
      case INT:
        run_time = (double)the_event->evt.asmt.rhs.ival;
        have_run_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. runTime unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_INITIALCONFIG:
      if( the_type == STRING ){
        strcpy( initial_config, the_event->evt.asmt.rhs.sval );
        have_initial_config = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. initialConfig was not a string assignment.\n" );
      return 0;
      break;
      
    case G_FINALCONFIG:
      if( the_type == STRING ){
        strcpy( final_config, the_event->evt.asmt.rhs.sval );
        have_final_config = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. finalConfig was not a string assignment.\n" );
      return 0;
      break;
      
    case G_NMOL:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. nMol is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        n_mol = (int)the_event->evt.asmt.rhs.dval;
        have_n_mol = 1;
        return 1;
        break;
        
      case INT:
        n_mol = the_event->evt.asmt.rhs.ival;
        have_n_mol = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. nMol unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_DENSITY:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. density is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        density = the_event->evt.asmt.rhs.dval;
        have_density = 1;
        return 1;
        break;
        
      case INT:
        density = (double)the_event->evt.asmt.rhs.ival;
        have_density = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. density unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOX:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. box is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box = the_event->evt.asmt.rhs.dval;
        have_box = 1;
        return 1;
        break;
        
      case INT:
        box = (double)the_event->evt.asmt.rhs.ival;
        have_box = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. box unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOXX:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. boxX is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box_x = the_event->evt.asmt.rhs.dval;
        have_box_x = 1;
        return 1;
        break;
        
      case INT:
        box_x = (double)the_event->evt.asmt.rhs.ival;
        have_box_x = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. boxX unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOXY:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. boxY is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box_y = the_event->evt.asmt.rhs.dval;
        have_box_y = 1;
        return 1;
        break;
        
      case INT:
        box_y = (double)the_event->evt.asmt.rhs.ival;
        have_box_y = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. boxY unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_BOXZ:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. boxZ is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        box_z = the_event->evt.asmt.rhs.dval;
        have_box_z = 1;
        return 1;
        break;
        
      case INT:
        box_z = (double)the_event->evt.asmt.rhs.ival;
        have_box_z = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. boxZ unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_SAMPLETIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. sampleTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        sample_time = the_event->evt.asmt.rhs.dval;
        have_sample_time = 1;
        return 1;
        break;
        
      case INT:
        sample_time = (double)the_event->evt.asmt.rhs.ival;
        have_sample_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. sampleTime unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_STATUSTIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. statusTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        status_time = the_event->evt.asmt.rhs.dval;
        have_status_time = 1;
        return 1;
        break;
        
      case INT:
        status_time = (double)the_event->evt.asmt.rhs.ival;
        have_status_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. statusTime unrecognized.\n" );
        return 0;
        break;
      }
      break;

   case G_THERMALTIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. thermalTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        thermal_time = the_event->evt.asmt.rhs.dval;
        have_thermal_time = 1;
        return 1;
        break;
        
      case INT:
        thermal_time = (double)the_event->evt.asmt.rhs.ival;
        have_thermal_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. thermalTime unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_ECR:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        ecr = the_event->evt.asmt.rhs.dval;
        have_ecr = 1;
        return 1;
        break;
        
      case INT:
        ecr = (double)the_event->evt.asmt.rhs.ival;
        have_ecr = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
        return 0;
        break;
      }
      break;

    case G_EST:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. electrostaticSkinThickness is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        est = the_event->evt.asmt.rhs.dval;
        have_est = 1;
        return 1;
        break;
        
      case INT:
        est = (double)the_event->evt.asmt.rhs.ival;
        have_est = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. electrostaticSkinThickness unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_DIELECTRIC:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. dielectric is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        dielectric = the_event->evt.asmt.rhs.dval;
        have_dielectric = 1;
        return 1;
        break;
        
      case INT:
        dielectric = (double)the_event->evt.asmt.rhs.ival;
        have_dielectric = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. dielectric unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_TEMPSET:
      if( the_type == STRING ){
        
        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
        else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
        else{
          the_event->err_msg = 
            strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
          return 0;
        }
        have_tempSet = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
      return 0;
      break;
      
    case G_USEPBC:
      if( the_type == STRING ){
        
        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
        else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
        else{
          the_event->err_msg = 
            strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
          return 0;
        }
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
      return 0;
      break;

    case G_USERF:
      if( the_type == STRING ){
        
        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
        else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
        else{
          the_event->err_msg = 
            strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
          return 0;
        }
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
      return 0;
      break;

    case G_TARGETPRESSURE:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. targetPressure is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        target_pressure = the_event->evt.asmt.rhs.dval;
        have_target_pressure = 1;
        return 1;
        break;
        
      case INT:
        target_pressure = (double)the_event->evt.asmt.rhs.ival;
        have_target_pressure = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. targetPressure unrecognized.\n" );
        return 0;
        break;
      }
      break;

    case G_QMASS:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. qMass is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        q_mass = the_event->evt.asmt.rhs.dval;
        have_q_mass = 1;
        return 1;
        break;
        
      case INT:
        q_mass = (double)the_event->evt.asmt.rhs.ival;
        have_q_mass = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. qMass unrecognized.\n" );
        return 0;
        break;
      }
      break;

    case G_TAURELAX:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. tauRelax is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        tau_relax = the_event->evt.asmt.rhs.dval;
        have_tau_relax = 1;
        return 1;
        break;
        
      case INT:
        tau_relax = (double)the_event->evt.asmt.rhs.ival;
        have_tau_relax = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. tauRelax unrecognized.\n" );
        return 0;
        break;
      }
      break;

    }
  }
  
  switch( the_type ){
    
  case STRING:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %s\n",
             lhs, the_event->evt.asmt.rhs.sval );
    break;
    
  case DOUBLE:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %lf\n",
             lhs, the_event->evt.asmt.rhs.dval );
    break;
    
  case INT:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %d\n",
             lhs, the_event->evt.asmt.rhs.ival );
    break;
    
  default:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = ?\n",
             lhs );
    break;
  }
  
  the_event->err_msg = strdup( err );
  return 0;
}

char* Globals::checkMe( void ){
  
  char err[300];
  short int have_err = 0;

  strcpy( err, "Global error. The following are required:\n" );
  
  if( !have_force_field ){
    strcat( err, "\t->forceField\n" );
    have_err= 1;
  }

  if( !have_n_components ){
    strcat( err, "\t->nComponents\n" );
    have_err= 1;
  }

  if( !have_target_temp ){
    strcat( err, "\t->targetTemp\n" );
    have_err= 1;
  }
  
  if( !have_ensemble ){
    strcat( err, "\t->ensemble\n" );
    have_err= 1;
  }
  
  if( !have_dt ){
    strcat( err, "\t->dt\n" );
    have_err= 1;
  }
  
  if( !have_run_time ){
    strcat( err, "\t->runTime\n" );
    have_err= 1;
  }
  
  if( have_err ) return strdup( err );
  
  return NULL;
}

int Globals::globalEnd( event* the_event ){
  
  the_event->err_msg = checkMe();
  if( the_event->err_msg != NULL ) return 0;

  return 1;
}

int Globals::hash( char* text ){

  register unsigned short int i = 0; // loop counter
  int key = 0; // the hash key
  
  while( text[i] != '\0' ){
    
    key = ( ( key << hash_shift ) + text[i] ) % hash_size;
    
    i++;
  }
  
  if( key < 0 ){

    // if the key is less than zero, we've had an overflow error

    sprintf( painCave.errMsg,
             "There has been an overflow error in the Globals' hash key.");
    painCave.isFatal = 1;
    simError();
#ifdef IS_MPI
    if( painCave.isEventLoop ){
      if( worldRank == 0 ) mpiInterfaceExit();
    }
#endif //is_mpi
  }
  
  return key;
}

void Globals::addHash( char* text, int token ){

  int key;
  LinkedCommand* the_element;

  the_element = new LinkedCommand;
  the_element->setValues( text, token );

  key = hash( text );
  the_element->setNext( command_table[key] );
  command_table[key] = the_element;
}
Revision:	474
Committed:	Mon Apr 7 21:42:19 2003 UTC (21 years, 3 months ago) by gezelter
File size:	21101 byte(s)
Log Message:	Fixes for NPT and NVT
#	Content
1	#include <cstdlib>
2	#include <cstdio>
3	#include <cstring>
4
5	#include "Globals.hpp"
6	#include "simError.h"
7	#ifdef IS_MPI
8	#include "mpiBASS.h"
9	#endif // is_mpi
10
11	/*
12	* The following section lists all of the defined tokens for the
13	* gloabal assignment statements. All are prefixed with a G_ to avoid
14	* stepping on any previously defined enumerations.
15	*
16	* NOTE: tokens start at 1, 0 is a resrved token number
17	*/
18
19	//required parameters
20	#define G_FORCEFIELD 1
21	#define G_NCOMPONENTS 2
22	#define G_TARGETTEMP 3
23	#define G_ENSEMBLE 4
24	#define G_DT 5
25	#define G_RUNTIME 6
26
27	//optional parameters
28	#define G_INITIALCONFIG 7
29	#define G_FINALCONFIG 8
30	#define G_NMOL 9
31	#define G_DENSITY 10
32	#define G_BOX 11
33	#define G_BOXX 12
34	#define G_BOXY 13
35	#define G_BOXZ 14
36	#define G_SAMPLETIME 15
37	#define G_STATUSTIME 16
38	#define G_ECR 17
39	#define G_DIELECTRIC 18
40	#define G_TEMPSET 19
41	#define G_THERMALTIME 20
42	#define G_USEPBC 21
43	#define G_MIXINGRULE 22
44	#define G_EST 23
45	#define G_USERF 24
46	#define G_TARGETPRESSURE 25
47	#define G_QMASS 26
48	#define G_TAURELAX 27
49
50
51	Globals::Globals(){
52
53	int i;
54
55	components = NULL;
56
57	command_table = new LinkedCommand*[hash_size];
58	for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
59
60	addHash( "forceField", G_FORCEFIELD );
61	addHash( "nComponents", G_NCOMPONENTS );
62	addHash( "targetTemp", G_TARGETTEMP );
63	addHash( "ensemble", G_ENSEMBLE );
64
65	addHash( "dt", G_DT );
66	addHash( "runTime", G_RUNTIME );
67
68	addHash( "initialConfig", G_INITIALCONFIG );
69	addHash( "finalConfig", G_FINALCONFIG );
70	addHash( "nMol", G_NMOL );
71	addHash( "density", G_DENSITY );
72	addHash( "box", G_BOX );
73	addHash( "boxX", G_BOXX );
74	addHash( "boxY", G_BOXY );
75	addHash( "boxZ", G_BOXZ );
76	addHash( "sampleTime", G_SAMPLETIME );
77	addHash( "statusTime", G_STATUSTIME );
78	addHash( "electrostaticCutoffRadius", G_ECR );
79	addHash( "dielectric", G_DIELECTRIC );
80	addHash( "tempSet", G_TEMPSET );
81	addHash( "thermalTime", G_THERMALTIME );
82	addHash( "mixingRule", G_MIXINGRULE);
83	addHash( "usePeriodicBoundaryConditions", G_USEPBC);
84	addHash( "electrostaticSkinThickness", G_EST );
85	addHash( "useReactionField", G_USERF );
86	addHash( "targetPressure", G_TARGETPRESSURE);
87	addHash( "qMass", G_QMASS);
88	addHash( "tauRelax", G_TAURELAX);
89
90	// define some default values
91
92	strcpy( mixingRule,"standard"); //default mixing rules to standard.
93	usePBC = 1; //default periodic boundry conditions to on
94	useRF = 0;
95
96	have_force_field = 0;
97	have_n_components = 0;
98	have_target_temp = 0;
99	have_ensemble = 0;
100	have_dt = 0;
101	have_run_time = 0;
102
103	have_initial_config = 0;
104	have_final_config = 0;
105	have_n_mol = 0;
106	have_density = 0;
107	have_box = 0;
108	have_box_x = 0;
109	have_box_y = 0;
110	have_box_y = 0;
111	have_box_z = 0;
112	have_sample_time = 0;
113	have_status_time = 0;
114	have_thermal_time = 0;
115	have_ecr = 0;
116	have_dielectric = 0;
117	have_tempSet = 0;
118	have_est = 0;
119	have_target_pressure =0;
120	have_q_mass = 0;
121	have_tau_relax = 0;
122	}
123
124	Globals::~Globals(){
125	int i;
126
127	for( i=0; i<hash_size; i++ ){
128	if( command_table[i] != NULL ) delete command_table[i];
129	}
130	delete[] command_table;
131
132	if( components != NULL ){
133	for( i=0; i<n_components; i++ ) delete components[i];
134	delete[] components;
135	}
136	}
137
138	int Globals::newComponent( event* the_event ){
139
140	current_component = new Component;
141	int index = the_event->evt.blk_index;
142	char err[200];
143
144	if( have_n_components && index < n_components )
145	components[index] = current_component;
146	else{
147	if( have_n_components ){
148	sprintf( err, "Globals error, %d out of nComponents range",
149	index );
150	the_event->err_msg = strdup( err );
151	return 0;
152	}
153	else{
154	the_event->err_msg = strdup("Globals error, nComponents not given before"
155	"first component declaration." );
156	return 0;
157	}
158	}
159
160	return 1;
161	}
162
163
164
165	int Globals::componentAssign( event* the_event ){
166
167	switch( the_event->evt.asmt.asmt_type ){
168
169	case STRING:
170	return current_component->assignString( the_event->evt.asmt.lhs,
171	the_event->evt.asmt.rhs.sval,
172	&(the_event->err_msg));
173	break;
174
175	case DOUBLE:
176	return current_component->assignDouble( the_event->evt.asmt.lhs,
177	the_event->evt.asmt.rhs.dval,
178	&(the_event->err_msg));
179	break;
180
181	case INT:
182	return current_component->assignInt( the_event->evt.asmt.lhs,
183	the_event->evt.asmt.rhs.ival,
184	&(the_event->err_msg));
185	break;
186
187	default:
188	the_event->err_msg = strdup( "Globals error. Invalid component"
189	" assignment type" );
190	return 0;
191	break;
192	}
193	return 0;
194	}
195
196	int Globals::componentStartIndex( event* the_event ){
197
198	current_component->startIndex( the_event->evt.si.array,
199	the_event->evt.si.n_elements );
200	return 1;
201	}
202
203	int Globals::componentEnd( event* the_event ){
204
205	the_event->err_msg = current_component->checkMe();
206	if( the_event->err_msg != NULL ) return 0;
207
208	return 1;
209	}
210
211	int Globals::globalAssign( event* the_event ){
212
213	int key;
214	int token;
215	interface_assign_type the_type = the_event->evt.asmt.asmt_type;
216	char* lhs = the_event->evt.asmt.lhs;
217	char err[300];
218
219	token = 0;
220	key = hash( lhs );
221	if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
222
223	if( token ){
224
225	switch( token ){
226
227	case G_FORCEFIELD:
228	if( the_type == STRING ){
229	strcpy( force_field, the_event->evt.asmt.rhs.sval );
230	have_force_field = 1;
231	return 1;
232	}
233
234	the_event->err_msg =
235	strdup( "Global error. forceField was not a string assignment.\n" );
236	return 0;
237	break;
238
239	case G_NCOMPONENTS:
240	if( the_type == STRING ){
241	the_event->err_msg =
242	strdup("Global error. nComponents is not a double or an int.\n" );
243	return 0;
244	}
245
246	else if( the_type == DOUBLE ){
247	n_components = (int)the_event->evt.asmt.rhs.dval;
248	components = new Component*[n_components];
249	have_n_components = 1;
250	return 1;
251	}
252
253	else{
254	n_components = the_event->evt.asmt.rhs.ival;
255	components = new Component*[n_components];
256	have_n_components = 1;
257	return 1;
258	}
259	break;
260
261	case G_TARGETTEMP:
262	switch( the_type ){
263
264	case STRING:
265	the_event->err_msg =
266	strdup( "Global error. targetTemp is not a double or int.\n" );
267	return 0;
268	break;
269
270	case DOUBLE:
271	target_temp = the_event->evt.asmt.rhs.dval;
272	have_target_temp = 1;
273	return 1;
274	break;
275
276	case INT:
277	target_temp = (double)the_event->evt.asmt.rhs.ival;
278	have_target_temp = 1;
279	return 1;
280	break;
281
282	default:
283	the_event->err_msg =
284	strdup( "Global error. targetTemp unrecognized.\n" );
285	return 0;
286	break;
287	}
288	break;
289
290	case G_ENSEMBLE:
291	if( the_type == STRING ){
292	strcpy( ensemble, the_event->evt.asmt.rhs.sval );
293	have_ensemble = 1;
294	return 1;
295	}
296
297	the_event->err_msg =
298	strdup( "Global error. ensemble was not assigned to a string\n" );
299	return 0;
300	break;
301
302	case G_MIXINGRULE:
303	if( the_type == STRING ){
304	strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
305	return 1;
306	}
307
308	the_event->err_msg =
309	strdup( "Global error. mixing rule was not assigned to a string\n" );
310	return 0;
311	break;
312
313	case G_DT:
314	switch( the_type ){
315
316	case STRING:
317	the_event->err_msg =
318	strdup( "Global error. dt is not a double or int.\n" );
319	return 0;
320	break;
321
322	case DOUBLE:
323	dt = the_event->evt.asmt.rhs.dval;
324	have_dt = 1;
325	return 1;
326	break;
327
328	case INT:
329	dt = (double)the_event->evt.asmt.rhs.ival;
330	have_dt = 1;
331	return 1;
332	break;
333
334	default:
335	the_event->err_msg =
336	strdup( "Global error. dt unrecognized.\n" );
337	return 0;
338	break;
339	}
340	break;
341
342	case G_RUNTIME:
343	switch( the_type ){
344
345	case STRING:
346	the_event->err_msg =
347	strdup( "Global error. runTime is not a double or int.\n" );
348	return 0;
349	break;
350
351	case DOUBLE:
352	run_time = the_event->evt.asmt.rhs.dval;
353	have_run_time = 1;
354	return 1;
355	break;
356
357	case INT:
358	run_time = (double)the_event->evt.asmt.rhs.ival;
359	have_run_time = 1;
360	return 1;
361	break;
362
363	default:
364	the_event->err_msg =
365	strdup( "Global error. runTime unrecognized.\n" );
366	return 0;
367	break;
368	}
369	break;
370
371	case G_INITIALCONFIG:
372	if( the_type == STRING ){
373	strcpy( initial_config, the_event->evt.asmt.rhs.sval );
374	have_initial_config = 1;
375	return 1;
376	}
377
378	the_event->err_msg =
379	strdup( "Global error. initialConfig was not a string assignment.\n" );
380	return 0;
381	break;
382
383	case G_FINALCONFIG:
384	if( the_type == STRING ){
385	strcpy( final_config, the_event->evt.asmt.rhs.sval );
386	have_final_config = 1;
387	return 1;
388	}
389
390	the_event->err_msg =
391	strdup( "Global error. finalConfig was not a string assignment.\n" );
392	return 0;
393	break;
394
395	case G_NMOL:
396	switch( the_type ){
397
398	case STRING:
399	the_event->err_msg =
400	strdup( "Global error. nMol is not a double or int.\n" );
401	return 0;
402	break;
403
404	case DOUBLE:
405	n_mol = (int)the_event->evt.asmt.rhs.dval;
406	have_n_mol = 1;
407	return 1;
408	break;
409
410	case INT:
411	n_mol = the_event->evt.asmt.rhs.ival;
412	have_n_mol = 1;
413	return 1;
414	break;
415
416	default:
417	the_event->err_msg =
418	strdup( "Global error. nMol unrecognized.\n" );
419	return 0;
420	break;
421	}
422	break;
423
424	case G_DENSITY:
425	switch( the_type ){
426
427	case STRING:
428	the_event->err_msg =
429	strdup( "Global error. density is not a double or int.\n" );
430	return 0;
431	break;
432
433	case DOUBLE:
434	density = the_event->evt.asmt.rhs.dval;
435	have_density = 1;
436	return 1;
437	break;
438
439	case INT:
440	density = (double)the_event->evt.asmt.rhs.ival;
441	have_density = 1;
442	return 1;
443	break;
444
445	default:
446	the_event->err_msg =
447	strdup( "Global error. density unrecognized.\n" );
448	return 0;
449	break;
450	}
451	break;
452
453	case G_BOX:
454	switch( the_type ){
455
456	case STRING:
457	the_event->err_msg =
458	strdup( "Global error. box is not a double or int.\n" );
459	return 0;
460	break;
461
462	case DOUBLE:
463	box = the_event->evt.asmt.rhs.dval;
464	have_box = 1;
465	return 1;
466	break;
467
468	case INT:
469	box = (double)the_event->evt.asmt.rhs.ival;
470	have_box = 1;
471	return 1;
472	break;
473
474	default:
475	the_event->err_msg =
476	strdup( "Global error. box unrecognized.\n" );
477	return 0;
478	break;
479	}
480	break;
481
482	case G_BOXX:
483	switch( the_type ){
484
485	case STRING:
486	the_event->err_msg =
487	strdup( "Global error. boxX is not a double or int.\n" );
488	return 0;
489	break;
490
491	case DOUBLE:
492	box_x = the_event->evt.asmt.rhs.dval;
493	have_box_x = 1;
494	return 1;
495	break;
496
497	case INT:
498	box_x = (double)the_event->evt.asmt.rhs.ival;
499	have_box_x = 1;
500	return 1;
501	break;
502
503	default:
504	the_event->err_msg =
505	strdup( "Global error. boxX unrecognized.\n" );
506	return 0;
507	break;
508	}
509	break;
510
511	case G_BOXY:
512	switch( the_type ){
513
514	case STRING:
515	the_event->err_msg =
516	strdup( "Global error. boxY is not a double or int.\n" );
517	return 0;
518	break;
519
520	case DOUBLE:
521	box_y = the_event->evt.asmt.rhs.dval;
522	have_box_y = 1;
523	return 1;
524	break;
525
526	case INT:
527	box_y = (double)the_event->evt.asmt.rhs.ival;
528	have_box_y = 1;
529	return 1;
530	break;
531
532	default:
533	the_event->err_msg =
534	strdup( "Global error. boxY unrecognized.\n" );
535	return 0;
536	break;
537	}
538	break;
539
540	case G_BOXZ:
541	switch( the_type ){
542
543	case STRING:
544	the_event->err_msg =
545	strdup( "Global error. boxZ is not a double or int.\n" );
546	return 0;
547	break;
548
549	case DOUBLE:
550	box_z = the_event->evt.asmt.rhs.dval;
551	have_box_z = 1;
552	return 1;
553	break;
554
555	case INT:
556	box_z = (double)the_event->evt.asmt.rhs.ival;
557	have_box_z = 1;
558	return 1;
559	break;
560
561	default:
562	the_event->err_msg =
563	strdup( "Global error. boxZ unrecognized.\n" );
564	return 0;
565	break;
566	}
567	break;
568
569	case G_SAMPLETIME:
570	switch( the_type ){
571
572	case STRING:
573	the_event->err_msg =
574	strdup( "Global error. sampleTime is not a double or int.\n" );
575	return 0;
576	break;
577
578	case DOUBLE:
579	sample_time = the_event->evt.asmt.rhs.dval;
580	have_sample_time = 1;
581	return 1;
582	break;
583
584	case INT:
585	sample_time = (double)the_event->evt.asmt.rhs.ival;
586	have_sample_time = 1;
587	return 1;
588	break;
589
590	default:
591	the_event->err_msg =
592	strdup( "Global error. sampleTime unrecognized.\n" );
593	return 0;
594	break;
595	}
596	break;
597
598	case G_STATUSTIME:
599	switch( the_type ){
600
601	case STRING:
602	the_event->err_msg =
603	strdup( "Global error. statusTime is not a double or int.\n" );
604	return 0;
605	break;
606
607	case DOUBLE:
608	status_time = the_event->evt.asmt.rhs.dval;
609	have_status_time = 1;
610	return 1;
611	break;
612
613	case INT:
614	status_time = (double)the_event->evt.asmt.rhs.ival;
615	have_status_time = 1;
616	return 1;
617	break;
618
619	default:
620	the_event->err_msg =
621	strdup( "Global error. statusTime unrecognized.\n" );
622	return 0;
623	break;
624	}
625	break;
626
627	case G_THERMALTIME:
628	switch( the_type ){
629
630	case STRING:
631	the_event->err_msg =
632	strdup( "Global error. thermalTime is not a double or int.\n" );
633	return 0;
634	break;
635
636	case DOUBLE:
637	thermal_time = the_event->evt.asmt.rhs.dval;
638	have_thermal_time = 1;
639	return 1;
640	break;
641
642	case INT:
643	thermal_time = (double)the_event->evt.asmt.rhs.ival;
644	have_thermal_time = 1;
645	return 1;
646	break;
647
648	default:
649	the_event->err_msg =
650	strdup( "Global error. thermalTime unrecognized.\n" );
651	return 0;
652	break;
653	}
654	break;
655
656	case G_ECR:
657	switch( the_type ){
658
659	case STRING:
660	the_event->err_msg =
661	strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
662	return 0;
663	break;
664
665	case DOUBLE:
666	ecr = the_event->evt.asmt.rhs.dval;
667	have_ecr = 1;
668	return 1;
669	break;
670
671	case INT:
672	ecr = (double)the_event->evt.asmt.rhs.ival;
673	have_ecr = 1;
674	return 1;
675	break;
676
677	default:
678	the_event->err_msg =
679	strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
680	return 0;
681	break;
682	}
683	break;
684
685	case G_EST:
686	switch( the_type ){
687
688	case STRING:
689	the_event->err_msg =
690	strdup( "Global error. electrostaticSkinThickness is not a double or int.\n" );
691	return 0;
692	break;
693
694	case DOUBLE:
695	est = the_event->evt.asmt.rhs.dval;
696	have_est = 1;
697	return 1;
698	break;
699
700	case INT:
701	est = (double)the_event->evt.asmt.rhs.ival;
702	have_est = 1;
703	return 1;
704	break;
705
706	default:
707	the_event->err_msg =
708	strdup( "Global error. electrostaticSkinThickness unrecognized.\n" );
709	return 0;
710	break;
711	}
712	break;
713
714	case G_DIELECTRIC:
715	switch( the_type ){
716
717	case STRING:
718	the_event->err_msg =
719	strdup( "Global error. dielectric is not a double or int.\n" );
720	return 0;
721	break;
722
723	case DOUBLE:
724	dielectric = the_event->evt.asmt.rhs.dval;
725	have_dielectric = 1;
726	return 1;
727	break;
728
729	case INT:
730	dielectric = (double)the_event->evt.asmt.rhs.ival;
731	have_dielectric = 1;
732	return 1;
733	break;
734
735	default:
736	the_event->err_msg =
737	strdup( "Global error. dielectric unrecognized.\n" );
738	return 0;
739	break;
740	}
741	break;
742
743	case G_TEMPSET:
744	if( the_type == STRING ){
745
746	if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
747	else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
748	else{
749	the_event->err_msg =
750	strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
751	return 0;
752	}
753	have_tempSet = 1;
754	return 1;
755	}
756
757	the_event->err_msg =
758	strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
759	return 0;
760	break;
761
762	case G_USEPBC:
763	if( the_type == STRING ){
764
765	if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
766	else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
767	else{
768	the_event->err_msg =
769	strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
770	return 0;
771	}
772	return 1;
773	}
774
775	the_event->err_msg =
776	strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
777	return 0;
778	break;
779
780	case G_USERF:
781	if( the_type == STRING ){
782
783	if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
784	else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
785	else{
786	the_event->err_msg =
787	strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
788	return 0;
789	}
790	return 1;
791	}
792
793	the_event->err_msg =
794	strdup( "Global error. useReactionField was not \"true\" or \"false\".\n" );
795	return 0;
796	break;
797
798	case G_TARGETPRESSURE:
799	switch( the_type ){
800
801	case STRING:
802	the_event->err_msg =
803	strdup( "Global error. targetPressure is not a double or int.\n" );
804	return 0;
805	break;
806
807	case DOUBLE:
808	target_pressure = the_event->evt.asmt.rhs.dval;
809	have_target_pressure = 1;
810	return 1;
811	break;
812
813	case INT:
814	target_pressure = (double)the_event->evt.asmt.rhs.ival;
815	have_target_pressure = 1;
816	return 1;
817	break;
818
819	default:
820	the_event->err_msg =
821	strdup( "Global error. targetPressure unrecognized.\n" );
822	return 0;
823	break;
824	}
825	break;
826
827	case G_QMASS:
828	switch( the_type ){
829
830	case STRING:
831	the_event->err_msg =
832	strdup( "Global error. qMass is not a double or int.\n" );
833	return 0;
834	break;
835
836	case DOUBLE:
837	q_mass = the_event->evt.asmt.rhs.dval;
838	have_q_mass = 1;
839	return 1;
840	break;
841
842	case INT:
843	q_mass = (double)the_event->evt.asmt.rhs.ival;
844	have_q_mass = 1;
845	return 1;
846	break;
847
848	default:
849	the_event->err_msg =
850	strdup( "Global error. qMass unrecognized.\n" );
851	return 0;
852	break;
853	}
854	break;
855
856	case G_TAURELAX:
857	switch( the_type ){
858
859	case STRING:
860	the_event->err_msg =
861	strdup( "Global error. tauRelax is not a double or int.\n" );
862	return 0;
863	break;
864
865	case DOUBLE:
866	tau_relax = the_event->evt.asmt.rhs.dval;
867	have_tau_relax = 1;
868	return 1;
869	break;
870
871	case INT:
872	tau_relax = (double)the_event->evt.asmt.rhs.ival;
873	have_tau_relax = 1;
874	return 1;
875	break;
876
877	default:
878	the_event->err_msg =
879	strdup( "Global error. tauRelax unrecognized.\n" );
880	return 0;
881	break;
882	}
883	break;
884
885	}
886	}
887
888	switch( the_type ){
889
890	case STRING:
891	sprintf( err,
892	"Global error. Unrecognized assignment:\n"
893	"\t-> %s = %s\n",
894	lhs, the_event->evt.asmt.rhs.sval );
895	break;
896
897	case DOUBLE:
898	sprintf( err,
899	"Global error. Unrecognized assignment:\n"
900	"\t-> %s = %lf\n",
901	lhs, the_event->evt.asmt.rhs.dval );
902	break;
903
904	case INT:
905	sprintf( err,
906	"Global error. Unrecognized assignment:\n"
907	"\t-> %s = %d\n",
908	lhs, the_event->evt.asmt.rhs.ival );
909	break;
910
911	default:
912	sprintf( err,
913	"Global error. Unrecognized assignment:\n"
914	"\t-> %s = ?\n",
915	lhs );
916	break;
917	}
918
919	the_event->err_msg = strdup( err );
920	return 0;
921	}
922
923	char* Globals::checkMe( void ){
924
925	char err[300];
926	short int have_err = 0;
927
928	strcpy( err, "Global error. The following are required:\n" );
929
930	if( !have_force_field ){
931	strcat( err, "\t->forceField\n" );
932	have_err= 1;
933	}
934
935	if( !have_n_components ){
936	strcat( err, "\t->nComponents\n" );
937	have_err= 1;
938	}
939
940	if( !have_target_temp ){
941	strcat( err, "\t->targetTemp\n" );
942	have_err= 1;
943	}
944
945	if( !have_ensemble ){
946	strcat( err, "\t->ensemble\n" );
947	have_err= 1;
948	}
949
950	if( !have_dt ){
951	strcat( err, "\t->dt\n" );
952	have_err= 1;
953	}
954
955	if( !have_run_time ){
956	strcat( err, "\t->runTime\n" );
957	have_err= 1;
958	}
959
960	if( have_err ) return strdup( err );
961
962	return NULL;
963	}
964
965	int Globals::globalEnd( event* the_event ){
966
967	the_event->err_msg = checkMe();
968	if( the_event->err_msg != NULL ) return 0;
969
970	return 1;
971	}
972
973	int Globals::hash( char* text ){
974
975	register unsigned short int i = 0; // loop counter
976	int key = 0; // the hash key
977
978	while( text[i] != '\0' ){
979
980	key = ( ( key << hash_shift ) + text[i] ) % hash_size;
981
982	i++;
983	}
984
985	if( key < 0 ){
986
987	// if the key is less than zero, we've had an overflow error
988
989	sprintf( painCave.errMsg,
990	"There has been an overflow error in the Globals' hash key.");
991	painCave.isFatal = 1;
992	simError();
993	#ifdef IS_MPI
994	if( painCave.isEventLoop ){
995	if( worldRank == 0 ) mpiInterfaceExit();
996	}
997	#endif //is_mpi
998	}
999
1000	return key;
1001	}
1002
1003	void Globals::addHash( char* text, int token ){
1004
1005	int key;
1006	LinkedCommand* the_element;
1007
1008	the_element = new LinkedCommand;
1009	the_element->setValues( text, token );
1010
1011	key = hash( text );
1012	the_element->setNext( command_table[key] );
1013	command_table[key] = the_element;
1014	}