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_RRF           17
#define G_DIELECTRIC    18
#define G_TEMPSET       19
#define G_THERMALTIME   20
#define G_USEPBC 21
#define G_MIXINGRULE 22


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( "rRF",           G_RRF );
  addHash( "dielectric",    G_DIELECTRIC );
  addHash( "tempSet",       G_TEMPSET );
  addHash( "thermalTime",   G_THERMALTIME );
  addHash( "mixingRule",    G_MIXINGRULE);
  addHash( "periodicBox",   G_USEPBC);
  
  // define some default values 

  strcpy( mixingRule,"standard");  //default mixing rules to standard.
  usePBC = 1; //default  periodic boundry conditions to on
  

  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_rrf =            0;
  have_dielectric =     0;
  have_tempSet =        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_RRF:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. rRF is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        rRF = the_event->evt.asmt.rhs.dval;
        have_rrf = 1;
        return 1;
        break;
        
      case INT:
        rRF = (double)the_event->evt.asmt.rhs.ival;
        have_rrf = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. rRF 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( !strcmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
        else if( !strcmp( "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( !strcmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
        else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
        else{
          the_event->err_msg = 
            strdup( "Global error. periodicBoundryConditions was not \"true\" or \"false\".\n" );
          return 0;
        }
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
      return 0;
      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:	377
Committed:	Fri Mar 21 17:42:12 2003 UTC (21 years, 3 months ago) by mmeineke
Original Path:	*branches/mmeineke/OOPSE/libBASS/Globals.cpp*
File size:	17772 byte(s)
Log Message:	New OOPSE Tree
#	User	Rev	Content
1	mmeineke	377	#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_RRF 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
45
46			Globals::Globals(){
47
48			int i;
49
50			components = NULL;
51
52			command_table = new LinkedCommand*[hash_size];
53			for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
54
55			addHash( "forceField", G_FORCEFIELD );
56			addHash( "nComponents", G_NCOMPONENTS );
57			addHash( "targetTemp", G_TARGETTEMP );
58			addHash( "ensemble", G_ENSEMBLE );
59
60			addHash( "dt", G_DT );
61			addHash( "runTime", G_RUNTIME );
62
63			addHash( "initialConfig", G_INITIALCONFIG );
64			addHash( "finalConfig", G_FINALCONFIG );
65			addHash( "nMol", G_NMOL );
66			addHash( "density", G_DENSITY );
67			addHash( "box", G_BOX );
68			addHash( "boxX", G_BOXX );
69			addHash( "boxY", G_BOXY );
70			addHash( "boxZ", G_BOXZ );
71			addHash( "sampleTime", G_SAMPLETIME );
72			addHash( "statusTime", G_STATUSTIME );
73			addHash( "rRF", G_RRF );
74			addHash( "dielectric", G_DIELECTRIC );
75			addHash( "tempSet", G_TEMPSET );
76			addHash( "thermalTime", G_THERMALTIME );
77			addHash( "mixingRule", G_MIXINGRULE);
78			addHash( "periodicBox", G_USEPBC);
79
80			// define some default values
81
82			strcpy( mixingRule,"standard"); //default mixing rules to standard.
83			usePBC = 1; //default periodic boundry conditions to on
84
85
86			have_force_field = 0;
87			have_n_components = 0;
88			have_target_temp = 0;
89			have_ensemble = 0;
90			have_dt = 0;
91			have_run_time = 0;
92
93			have_initial_config = 0;
94			have_final_config = 0;
95			have_n_mol = 0;
96			have_density = 0;
97			have_box = 0;
98			have_box_x = 0;
99			have_box_y = 0;
100			have_box_y = 0;
101			have_box_z = 0;
102			have_sample_time = 0;
103			have_status_time = 0;
104			have_thermal_time = 0;
105			have_rrf = 0;
106			have_dielectric = 0;
107			have_tempSet = 0;
108			}
109
110			Globals::~Globals(){
111			int i;
112
113			for( i=0; i<hash_size; i++ ){
114			if( command_table[i] != NULL ) delete command_table[i];
115			}
116			delete[] command_table;
117
118			if( components != NULL ){
119			for( i=0; i<n_components; i++ ) delete components[i];
120			delete[] components;
121			}
122			}
123
124			int Globals::newComponent( event* the_event ){
125
126			current_component = new Component;
127			int index = the_event->evt.blk_index;
128			char err[200];
129
130			if( have_n_components && index < n_components )
131			components[index] = current_component;
132			else{
133			if( have_n_components ){
134			sprintf( err, "Globals error, %d out of nComponents range",
135			index );
136			the_event->err_msg = strdup( err );
137			return 0;
138			}
139			else{
140			the_event->err_msg = strdup("Globals error, nComponents not given before"
141			"first component declaration." );
142			return 0;
143			}
144			}
145
146			return 1;
147			}
148
149
150
151			int Globals::componentAssign( event* the_event ){
152
153			switch( the_event->evt.asmt.asmt_type ){
154
155			case STRING:
156			return current_component->assignString( the_event->evt.asmt.lhs,
157			the_event->evt.asmt.rhs.sval,
158			&(the_event->err_msg));
159			break;
160
161			case DOUBLE:
162			return current_component->assignDouble( the_event->evt.asmt.lhs,
163			the_event->evt.asmt.rhs.dval,
164			&(the_event->err_msg));
165			break;
166
167			case INT:
168			return current_component->assignInt( the_event->evt.asmt.lhs,
169			the_event->evt.asmt.rhs.ival,
170			&(the_event->err_msg));
171			break;
172
173			default:
174			the_event->err_msg = strdup( "Globals error. Invalid component"
175			" assignment type" );
176			return 0;
177			break;
178			}
179			return 0;
180			}
181
182			int Globals::componentStartIndex( event* the_event ){
183
184			current_component->startIndex( the_event->evt.si.array,
185			the_event->evt.si.n_elements );
186			return 1;
187			}
188
189			int Globals::componentEnd( event* the_event ){
190
191			the_event->err_msg = current_component->checkMe();
192			if( the_event->err_msg != NULL ) return 0;
193
194			return 1;
195			}
196
197			int Globals::globalAssign( event* the_event ){
198
199			int key;
200			int token;
201			interface_assign_type the_type = the_event->evt.asmt.asmt_type;
202			char* lhs = the_event->evt.asmt.lhs;
203			char err[300];
204
205			token = 0;
206			key = hash( lhs );
207			if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
208
209			if( token ){
210
211			switch( token ){
212
213			case G_FORCEFIELD:
214			if( the_type == STRING ){
215			strcpy( force_field, the_event->evt.asmt.rhs.sval );
216			have_force_field = 1;
217			return 1;
218			}
219
220			the_event->err_msg =
221			strdup( "Global error. forceField was not a string assignment.\n" );
222			return 0;
223			break;
224
225			case G_NCOMPONENTS:
226			if( the_type == STRING ){
227			the_event->err_msg =
228			strdup("Global error. nComponents is not a double or an int.\n" );
229			return 0;
230			}
231
232			else if( the_type == DOUBLE ){
233			n_components = (int)the_event->evt.asmt.rhs.dval;
234			components = new Component*[n_components];
235			have_n_components = 1;
236			return 1;
237			}
238
239			else{
240			n_components = the_event->evt.asmt.rhs.ival;
241			components = new Component*[n_components];
242			have_n_components = 1;
243			return 1;
244			}
245			break;
246
247			case G_TARGETTEMP:
248			switch( the_type ){
249
250			case STRING:
251			the_event->err_msg =
252			strdup( "Global error. targetTemp is not a double or int.\n" );
253			return 0;
254			break;
255
256			case DOUBLE:
257			target_temp = the_event->evt.asmt.rhs.dval;
258			have_target_temp = 1;
259			return 1;
260			break;
261
262			case INT:
263			target_temp = (double)the_event->evt.asmt.rhs.ival;
264			have_target_temp = 1;
265			return 1;
266			break;
267
268			default:
269			the_event->err_msg =
270			strdup( "Global error. targetTemp unrecognized.\n" );
271			return 0;
272			break;
273			}
274			break;
275
276			case G_ENSEMBLE:
277			if( the_type == STRING ){
278			strcpy( ensemble, the_event->evt.asmt.rhs.sval );
279			have_ensemble = 1;
280			return 1;
281			}
282
283			the_event->err_msg =
284			strdup( "Global error. ensemble was not assigned to a string\n" );
285			return 0;
286			break;
287
288			case G_MIXINGRULE:
289			if( the_type == STRING ){
290			strcpy( mixingRule, the_event->evt.asmt.rhs.sval );
291			return 1;
292			}
293
294			the_event->err_msg =
295			strdup( "Global error. mixing rule was not assigned to a string\n" );
296			return 0;
297			break;
298
299			case G_DT:
300			switch( the_type ){
301
302			case STRING:
303			the_event->err_msg =
304			strdup( "Global error. dt is not a double or int.\n" );
305			return 0;
306			break;
307
308			case DOUBLE:
309			dt = the_event->evt.asmt.rhs.dval;
310			have_dt = 1;
311			return 1;
312			break;
313
314			case INT:
315			dt = (double)the_event->evt.asmt.rhs.ival;
316			have_dt = 1;
317			return 1;
318			break;
319
320			default:
321			the_event->err_msg =
322			strdup( "Global error. dt unrecognized.\n" );
323			return 0;
324			break;
325			}
326			break;
327
328			case G_RUNTIME:
329			switch( the_type ){
330
331			case STRING:
332			the_event->err_msg =
333			strdup( "Global error. runTime is not a double or int.\n" );
334			return 0;
335			break;
336
337			case DOUBLE:
338			run_time = the_event->evt.asmt.rhs.dval;
339			have_run_time = 1;
340			return 1;
341			break;
342
343			case INT:
344			run_time = (double)the_event->evt.asmt.rhs.ival;
345			have_run_time = 1;
346			return 1;
347			break;
348
349			default:
350			the_event->err_msg =
351			strdup( "Global error. runTime unrecognized.\n" );
352			return 0;
353			break;
354			}
355			break;
356
357			case G_INITIALCONFIG:
358			if( the_type == STRING ){
359			strcpy( initial_config, the_event->evt.asmt.rhs.sval );
360			have_initial_config = 1;
361			return 1;
362			}
363
364			the_event->err_msg =
365			strdup( "Global error. initialConfig was not a string assignment.\n" );
366			return 0;
367			break;
368
369			case G_FINALCONFIG:
370			if( the_type == STRING ){
371			strcpy( final_config, the_event->evt.asmt.rhs.sval );
372			have_final_config = 1;
373			return 1;
374			}
375
376			the_event->err_msg =
377			strdup( "Global error. finalConfig was not a string assignment.\n" );
378			return 0;
379			break;
380
381			case G_NMOL:
382			switch( the_type ){
383
384			case STRING:
385			the_event->err_msg =
386			strdup( "Global error. nMol is not a double or int.\n" );
387			return 0;
388			break;
389
390			case DOUBLE:
391			n_mol = (int)the_event->evt.asmt.rhs.dval;
392			have_n_mol = 1;
393			return 1;
394			break;
395
396			case INT:
397			n_mol = the_event->evt.asmt.rhs.ival;
398			have_n_mol = 1;
399			return 1;
400			break;
401
402			default:
403			the_event->err_msg =
404			strdup( "Global error. nMol unrecognized.\n" );
405			return 0;
406			break;
407			}
408			break;
409
410			case G_DENSITY:
411			switch( the_type ){
412
413			case STRING:
414			the_event->err_msg =
415			strdup( "Global error. density is not a double or int.\n" );
416			return 0;
417			break;
418
419			case DOUBLE:
420			density = the_event->evt.asmt.rhs.dval;
421			have_density = 1;
422			return 1;
423			break;
424
425			case INT:
426			density = (double)the_event->evt.asmt.rhs.ival;
427			have_density = 1;
428			return 1;
429			break;
430
431			default:
432			the_event->err_msg =
433			strdup( "Global error. density unrecognized.\n" );
434			return 0;
435			break;
436			}
437			break;
438
439			case G_BOX:
440			switch( the_type ){
441
442			case STRING:
443			the_event->err_msg =
444			strdup( "Global error. box is not a double or int.\n" );
445			return 0;
446			break;
447
448			case DOUBLE:
449			box = the_event->evt.asmt.rhs.dval;
450			have_box = 1;
451			return 1;
452			break;
453
454			case INT:
455			box = (double)the_event->evt.asmt.rhs.ival;
456			have_box = 1;
457			return 1;
458			break;
459
460			default:
461			the_event->err_msg =
462			strdup( "Global error. box unrecognized.\n" );
463			return 0;
464			break;
465			}
466			break;
467
468			case G_BOXX:
469			switch( the_type ){
470
471			case STRING:
472			the_event->err_msg =
473			strdup( "Global error. boxX is not a double or int.\n" );
474			return 0;
475			break;
476
477			case DOUBLE:
478			box_x = the_event->evt.asmt.rhs.dval;
479			have_box_x = 1;
480			return 1;
481			break;
482
483			case INT:
484			box_x = (double)the_event->evt.asmt.rhs.ival;
485			have_box_x = 1;
486			return 1;
487			break;
488
489			default:
490			the_event->err_msg =
491			strdup( "Global error. boxX unrecognized.\n" );
492			return 0;
493			break;
494			}
495			break;
496
497			case G_BOXY:
498			switch( the_type ){
499
500			case STRING:
501			the_event->err_msg =
502			strdup( "Global error. boxY is not a double or int.\n" );
503			return 0;
504			break;
505
506			case DOUBLE:
507			box_y = the_event->evt.asmt.rhs.dval;
508			have_box_y = 1;
509			return 1;
510			break;
511
512			case INT:
513			box_y = (double)the_event->evt.asmt.rhs.ival;
514			have_box_y = 1;
515			return 1;
516			break;
517
518			default:
519			the_event->err_msg =
520			strdup( "Global error. boxY unrecognized.\n" );
521			return 0;
522			break;
523			}
524			break;
525
526			case G_BOXZ:
527			switch( the_type ){
528
529			case STRING:
530			the_event->err_msg =
531			strdup( "Global error. boxZ is not a double or int.\n" );
532			return 0;
533			break;
534
535			case DOUBLE:
536			box_z = the_event->evt.asmt.rhs.dval;
537			have_box_z = 1;
538			return 1;
539			break;
540
541			case INT:
542			box_z = (double)the_event->evt.asmt.rhs.ival;
543			have_box_z = 1;
544			return 1;
545			break;
546
547			default:
548			the_event->err_msg =
549			strdup( "Global error. boxZ unrecognized.\n" );
550			return 0;
551			break;
552			}
553			break;
554
555			case G_SAMPLETIME:
556			switch( the_type ){
557
558			case STRING:
559			the_event->err_msg =
560			strdup( "Global error. sampleTime is not a double or int.\n" );
561			return 0;
562			break;
563
564			case DOUBLE:
565			sample_time = the_event->evt.asmt.rhs.dval;
566			have_sample_time = 1;
567			return 1;
568			break;
569
570			case INT:
571			sample_time = (double)the_event->evt.asmt.rhs.ival;
572			have_sample_time = 1;
573			return 1;
574			break;
575
576			default:
577			the_event->err_msg =
578			strdup( "Global error. sampleTime unrecognized.\n" );
579			return 0;
580			break;
581			}
582			break;
583
584			case G_STATUSTIME:
585			switch( the_type ){
586
587			case STRING:
588			the_event->err_msg =
589			strdup( "Global error. statusTime is not a double or int.\n" );
590			return 0;
591			break;
592
593			case DOUBLE:
594			status_time = the_event->evt.asmt.rhs.dval;
595			have_status_time = 1;
596			return 1;
597			break;
598
599			case INT:
600			status_time = (double)the_event->evt.asmt.rhs.ival;
601			have_status_time = 1;
602			return 1;
603			break;
604
605			default:
606			the_event->err_msg =
607			strdup( "Global error. statusTime unrecognized.\n" );
608			return 0;
609			break;
610			}
611			break;
612
613			case G_THERMALTIME:
614			switch( the_type ){
615
616			case STRING:
617			the_event->err_msg =
618			strdup( "Global error. thermalTime is not a double or int.\n" );
619			return 0;
620			break;
621
622			case DOUBLE:
623			thermal_time = the_event->evt.asmt.rhs.dval;
624			have_thermal_time = 1;
625			return 1;
626			break;
627
628			case INT:
629			thermal_time = (double)the_event->evt.asmt.rhs.ival;
630			have_thermal_time = 1;
631			return 1;
632			break;
633
634			default:
635			the_event->err_msg =
636			strdup( "Global error. thermalTime unrecognized.\n" );
637			return 0;
638			break;
639			}
640			break;
641
642			case G_RRF:
643			switch( the_type ){
644
645			case STRING:
646			the_event->err_msg =
647			strdup( "Global error. rRF is not a double or int.\n" );
648			return 0;
649			break;
650
651			case DOUBLE:
652			rRF = the_event->evt.asmt.rhs.dval;
653			have_rrf = 1;
654			return 1;
655			break;
656
657			case INT:
658			rRF = (double)the_event->evt.asmt.rhs.ival;
659			have_rrf = 1;
660			return 1;
661			break;
662
663			default:
664			the_event->err_msg =
665			strdup( "Global error. rRF unrecognized.\n" );
666			return 0;
667			break;
668			}
669			break;
670
671			case G_DIELECTRIC:
672			switch( the_type ){
673
674			case STRING:
675			the_event->err_msg =
676			strdup( "Global error. dielectric is not a double or int.\n" );
677			return 0;
678			break;
679
680			case DOUBLE:
681			dielectric = the_event->evt.asmt.rhs.dval;
682			have_dielectric = 1;
683			return 1;
684			break;
685
686			case INT:
687			dielectric = (double)the_event->evt.asmt.rhs.ival;
688			have_dielectric = 1;
689			return 1;
690			break;
691
692			default:
693			the_event->err_msg =
694			strdup( "Global error. dielectric unrecognized.\n" );
695			return 0;
696			break;
697			}
698			break;
699
700			case G_TEMPSET:
701			if( the_type == STRING ){
702
703			if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
704			else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
705			else{
706			the_event->err_msg =
707			strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
708			return 0;
709			}
710			have_tempSet = 1;
711			return 1;
712			}
713
714			the_event->err_msg =
715			strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
716			return 0;
717			break;
718
719			case G_USEPBC:
720			if( the_type == STRING ){
721
722			if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
723			else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
724			else{
725			the_event->err_msg =
726			strdup( "Global error. periodicBoundryConditions was not \"true\" or \"false\".\n" );
727			return 0;
728			}
729			return 1;
730			}
731
732			the_event->err_msg =
733			strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
734			return 0;
735			break;
736			}
737			}
738
739			switch( the_type ){
740
741			case STRING:
742			sprintf( err,
743			"Global error. Unrecognized assignment:\n"
744			"\t-> %s = %s\n",
745			lhs, the_event->evt.asmt.rhs.sval );
746			break;
747
748			case DOUBLE:
749			sprintf( err,
750			"Global error. Unrecognized assignment:\n"
751			"\t-> %s = %lf\n",
752			lhs, the_event->evt.asmt.rhs.dval );
753			break;
754
755			case INT:
756			sprintf( err,
757			"Global error. Unrecognized assignment:\n"
758			"\t-> %s = %d\n",
759			lhs, the_event->evt.asmt.rhs.ival );
760			break;
761
762			default:
763			sprintf( err,
764			"Global error. Unrecognized assignment:\n"
765			"\t-> %s = ?\n",
766			lhs );
767			break;
768			}
769
770			the_event->err_msg = strdup( err );
771			return 0;
772			}
773
774			char* Globals::checkMe( void ){
775
776			char err[300];
777			short int have_err = 0;
778
779			strcpy( err, "Global error. The following are required:\n" );
780
781			if( !have_force_field ){
782			strcat( err, "\t->forceField\n" );
783			have_err= 1;
784			}
785
786			if( !have_n_components ){
787			strcat( err, "\t->nComponents\n" );
788			have_err= 1;
789			}
790
791			if( !have_target_temp ){
792			strcat( err, "\t->targetTemp\n" );
793			have_err= 1;
794			}
795
796			if( !have_ensemble ){
797			strcat( err, "\t->ensemble\n" );
798			have_err= 1;
799			}
800
801			if( !have_dt ){
802			strcat( err, "\t->dt\n" );
803			have_err= 1;
804			}
805
806			if( !have_run_time ){
807			strcat( err, "\t->runTime\n" );
808			have_err= 1;
809			}
810
811			if( have_err ) return strdup( err );
812
813			return NULL;
814			}
815
816			int Globals::globalEnd( event* the_event ){
817
818			the_event->err_msg = checkMe();
819			if( the_event->err_msg != NULL ) return 0;
820
821			return 1;
822			}
823
824			int Globals::hash( char* text ){
825
826			register unsigned short int i = 0; // loop counter
827			int key = 0; // the hash key
828
829			while( text[i] != '\0' ){
830
831			key = ( ( key << hash_shift ) + text[i] ) % hash_size;
832
833			i++;
834			}
835
836			if( key < 0 ){
837
838			// if the key is less than zero, we've had an overflow error
839
840			sprintf( painCave.errMsg,
841			"There has been an overflow error in the Globals' hash key.");
842			painCave.isFatal = 1;
843			simError();
844			#ifdef IS_MPI
845			if( painCave.isEventLoop ){
846			if( worldRank == 0 ) mpiInterfaceExit();
847			}
848			#endif //is_mpi
849			}
850
851			return key;
852			}
853
854			void Globals::addHash( char* text, int token ){
855
856			int key;
857			LinkedCommand* the_element;
858
859			the_element = new LinkedCommand;
860			the_element->setValues( text, token );
861
862			key = hash( text );
863			the_element->setNext( command_table[key] );
864			command_table[key] = the_element;
865			}