mdtools/interface_implementation/Globals.cpp

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

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