OOPSE/libBASS/Globals.cpp

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

#include "Globals.hpp"
#include "simError.h"
#ifdef IS_MPI
#include "mpiBASS.h"
#endif // is_mpi

/*
 * The following section lists all of the defined tokens for the
 * gloabal assignment statements. All are prefixed with a G_ to avoid
 * stepping on any previously defined enumerations. 
 *
 * NOTE: tokens start at 1, 0 is a resrved token number
 */

//required parameters
#define G_FORCEFIELD  1
#define G_NCOMPONENTS 2
#define G_TARGETTEMP  3
#define G_ENSEMBLE    4
#define G_DT          5
#define G_RUNTIME     6

//optional parameters
#define G_INITIALCONFIG 7
#define G_FINALCONFIG   8
#define G_NMOL          9
#define G_DENSITY       10
#define G_BOX           11
#define G_BOXX          12
#define G_BOXY          13
#define G_BOXZ          14
#define G_SAMPLETIME    15
#define G_STATUSTIME    16
#define G_RRF           17
#define G_DIELECTRIC    18
#define G_TEMPSET       19
#define G_THERMALTIME   20
#define G_USEPBC 21
#define G_MIXINGRULE 22


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

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

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

  addHash( "initialConfig", G_INITIALCONFIG );
  addHash( "finalConfig",   G_FINALCONFIG );
  addHash( "nMol",          G_NMOL );
  addHash( "density",       G_DENSITY );
  addHash( "box",           G_BOX );
  addHash( "boxX",          G_BOXX );
  addHash( "boxY",          G_BOXY );
  addHash( "boxZ",          G_BOXZ );
  addHash( "sampleTime",    G_SAMPLETIME );
  addHash( "statusTime",    G_STATUSTIME );
  addHash( "rRF",           G_RRF );
  addHash( "dielectric",    G_DIELECTRIC );
  addHash( "tempSet",       G_TEMPSET );
  addHash( "thermalTime",   G_THERMALTIME );
  addHash( "mixingRule",    G_MIXINGRULE);
  addHash( "periodicBox",   G_USEPBC);
  
  // define some default values 

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

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

Globals::~Globals(){
  int i;

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

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

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


int Globals::componentAssign( event* the_event ){

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

int Globals::componentStartIndex( event* the_event ){

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

int Globals::componentEnd( event* the_event ){

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

  return 1;
}

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

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

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

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

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

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

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

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

  return 1;
}

int Globals::hash( char* text ){

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

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

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

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

  int key;
  LinkedCommand* the_element;

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

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