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
#	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_ECR 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	#define G_EST 23
45	#define G_USERF 24
46
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	addHash( "electrostaticCutoffRadius", G_ECR );
76	addHash( "dielectric", G_DIELECTRIC );
77	addHash( "tempSet", G_TEMPSET );
78	addHash( "thermalTime", G_THERMALTIME );
79	addHash( "mixingRule", G_MIXINGRULE);
80	addHash( "usePeriodicBoundaryConditions", G_USEPBC);
81	addHash( "electrostaticSkinThickness", G_EST );
82	addHash( "useReactionField", G_USERF );
83
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	useRF = 0;
89
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	have_ecr = 0;
110	have_dielectric = 0;
111	have_tempSet = 0;
112	have_est = 0;
113	}
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	case G_ECR:
648	switch( the_type ){
649
650	case STRING:
651	the_event->err_msg =
652	strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
653	return 0;
654	break;
655
656	case DOUBLE:
657	ecr = the_event->evt.asmt.rhs.dval;
658	have_ecr = 1;
659	return 1;
660	break;
661
662	case INT:
663	ecr = (double)the_event->evt.asmt.rhs.ival;
664	have_ecr = 1;
665	return 1;
666	break;
667
668	default:
669	the_event->err_msg =
670	strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
671	return 0;
672	break;
673	}
674	break;
675
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
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	strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
761	return 0;
762	}
763	return 1;
764	}
765
766	the_event->err_msg =
767	strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
768	return 0;
769	break;
770
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	}
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	}