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_ECR           17
#define G_DIELECTRIC    18
#define G_TEMPSET       19
#define G_THERMALTIME   20
#define G_USEPBC        21
#define G_MIXINGRULE    22
#define G_EST           23
#define G_USERF         24


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( "electrostaticCutoffRadius",            G_ECR );
  addHash( "dielectric",    G_DIELECTRIC );
  addHash( "tempSet",       G_TEMPSET );
  addHash( "thermalTime",   G_THERMALTIME );
  addHash( "mixingRule",    G_MIXINGRULE);
  addHash( "usePeriodicBoundaryConditions",        G_USEPBC);
  addHash( "electrostaticSkinThickness",           G_EST );
  addHash( "useReactionField",                     G_USERF );
  
  // define some default values 

  strcpy( mixingRule,"standard");  //default mixing rules to standard.
  usePBC = 1; //default  periodic boundry conditions to on
  useRF  = 0;
  
  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_ecr =            0;
  have_dielectric =     0;
  have_tempSet =        0;
  have_est =            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_ECR:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        ecr = the_event->evt.asmt.rhs.dval;
        have_ecr = 1;
        return 1;
        break;
        
      case INT:
        ecr = (double)the_event->evt.asmt.rhs.ival;
        have_ecr = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
        return 0;
        break;
      }
      break;

    case G_EST:
      switch( the_type ){
        
      case STRING:
        the_event->err_msg = 
          strdup( "Global error. electrostaticSkinThickness is not a double or int.\n" );
        return 0;
        break;
        
      case DOUBLE:
        est = the_event->evt.asmt.rhs.dval;
        have_est = 1;
        return 1;
        break;
        
      case INT:
        est = (double)the_event->evt.asmt.rhs.ival;
        have_est = 1;
        return 1;
        break;
        
      default:
        the_event->err_msg = 
          strdup( "Global error. electrostaticSkinThickness 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. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
          return 0;
        }
        return 1;
      }
      
      the_event->err_msg = 
        strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
      return 0;
      break;

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