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
#define G_USEPBC 21
#define G_MIXINGRULE 22


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

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

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

  addHash( "initialConfig", G_INITIALCONFIG );
  addHash( "finalConfig",   G_FINALCONFIG );
  addHash( "nMol",          G_NMOL );
  addHash( "density",       G_DENSITY );
  addHash( "box",           G_BOX );
  addHash( "boxX",          G_BOXX );
  addHash( "boxY",          G_BOXY );
  addHash( "boxZ",          G_BOXZ );
  addHash( "sampleTime",    G_SAMPLETIME );
  addHash( "statusTime",    G_STATUSTIME );
  addHash( "rRF",           G_RRF );
  addHash( "dielectric",    G_DIELECTRIC );
  addHash( "tempSet",       G_TEMPSET );
  addHash( "thermalTime",   G_THERMALTIME );
  addHash("mixingRule", G_MIXINGRULE);
  mixingRule = "standard"; //default mixing rules to standard.
  addHash("periodicBoundryConditions", G_USEPBC);
  usePBC = 1; //default  periodic boundry conditions to on
  

  have_force_field =  0;
  have_n_components = 0;
  have_target_temp =  0;
  have_ensemble =     0;
  have_dt =           0;
  have_run_time =     0;
  
  have_initial_config = 0;
  have_final_config =   0;
  have_n_mol =          0;
  have_density =        0;
  have_box =            0;
  have_box_x =          0;
  have_box_y =          0;
  have_box_y =          0;
  have_box_z =          0;
  have_sample_time =    0;
  have_status_time =    0;
  have_thermal_time =   0;
  have_rrf =            0;
  have_dielectric =     0;
  have_tempSet =        0;
 }

Globals::~Globals(){
  int i;

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

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

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


int Globals::componentAssign( event* the_event ){

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

int Globals::componentStartIndex( event* the_event ){

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

int Globals::componentEnd( event* the_event ){

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

  return 1;
}

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

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

   case G_THERMALTIME:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. thermalTime is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        thermal_time = the_event->evt.asmt.rhs.dval;
        have_thermal_time = 1;
        return 1;
        break;
        
      case INT:
        thermal_time = (double)the_event->evt.asmt.rhs.ival;
        have_thermal_time = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. thermalTime unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_RRF:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. rRF is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        rRF = the_event->evt.asmt.rhs.dval;
        have_rrf = 1;
        return 1;
        break;
        
      case INT:
        rRF = (double)the_event->evt.asmt.rhs.ival;
        have_rrf = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. rRF unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_DIELECTRIC:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. dielectric is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        dielectric = the_event->evt.asmt.rhs.dval;
        have_dielectric = 1;
        return 1;
        break;
        
      case INT:
        dielectric = (double)the_event->evt.asmt.rhs.ival;
        have_dielectric = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. dielectric unrecognized.\n" );
        return 0;
        break;
      }
      break;
      
    case G_TEMPSET:
      if( the_type == STRING ){
        
        if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
        else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) tempSet = 0;
        else{
          the_event->err_msg = 
            strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
          return 0;
        }
        have_tempSet = 1;
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
      return 0;
      break;
      
    case G_USEPBC:
      if( the_type == STRING ){
        
        if( !strcmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
        else if( !strcmp( "false", the_event->evt.asmt.rhs.sval )) usePBC = 0;
        else{
          the_event->err_msg = 
            strdup( "Global error. periodicBoundryConditions was not \"true\" or \"false\".\n" );
          return 0;
        }
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. tempSet was not \"true\" or \"false\".\n" );
      return 0;
      break;
    }
  }
  
  switch( the_type ){
    
  case STRING:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %s\n",
             lhs, the_event->evt.asmt.rhs.sval );
    break;
    
  case DOUBLE:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %lf\n",
             lhs, the_event->evt.asmt.rhs.dval );
    break;
    
  case INT:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = %d\n",
             lhs, the_event->evt.asmt.rhs.ival );
    break;
    
  default:
    sprintf( err,
             "Global error. Unrecognized assignment:\n"
             "\t-> %s = ?\n",
             lhs );
    break;
  }
  
  the_event->err_msg = strdup( err );
  return 0;
}

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

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

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

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

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

  return 1;
}

int Globals::hash( char* text ){

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

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

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

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

  int key;
  LinkedCommand* the_element;

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

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