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
#define G_TARGETPRESSURE 25


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 );
  addHash( "targetPressure",                       G_TARGETPRESSURE);
  
  // 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;
  have_target_pressure =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( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) tempSet = 1;
        else if( !strcasecmp( "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( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) usePBC = 1;
        else if( !strcasecmp( "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( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
        else if( !strcasecmp( "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;

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