mdtools/interface_implementation/Globals.cpp

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

#include "Globals.hpp"
#include "mpiBASS.h"
#include "simError.h"

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