mdtools/interface_implementation/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


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 );

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