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, 3 months ago) by gezelter
File size:	19841 byte(s)
Log Message:	Added targetPressure to BASS
#	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	#define G_TARGETPRESSURE 25
47
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	addHash( "electrostaticCutoffRadius", G_ECR );
77	addHash( "dielectric", G_DIELECTRIC );
78	addHash( "tempSet", G_TEMPSET );
79	addHash( "thermalTime", G_THERMALTIME );
80	addHash( "mixingRule", G_MIXINGRULE);
81	addHash( "usePeriodicBoundaryConditions", G_USEPBC);
82	addHash( "electrostaticSkinThickness", G_EST );
83	addHash( "useReactionField", G_USERF );
84	addHash( "targetPressure", G_TARGETPRESSURE);
85
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	useRF = 0;
91
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	have_ecr = 0;
112	have_dielectric = 0;
113	have_tempSet = 0;
114	have_est = 0;
115	have_target_pressure =0;
116	}
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	case G_ECR:
651	switch( the_type ){
652
653	case STRING:
654	the_event->err_msg =
655	strdup( "Global error. electrostaticCutoffRadius is not a double or int.\n" );
656	return 0;
657	break;
658
659	case DOUBLE:
660	ecr = the_event->evt.asmt.rhs.dval;
661	have_ecr = 1;
662	return 1;
663	break;
664
665	case INT:
666	ecr = (double)the_event->evt.asmt.rhs.ival;
667	have_ecr = 1;
668	return 1;
669	break;
670
671	default:
672	the_event->err_msg =
673	strdup( "Global error. electrostaticCutoffRadius unrecognized.\n" );
674	return 0;
675	break;
676	}
677	break;
678
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
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	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	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	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	else{
762	the_event->err_msg =
763	strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
764	return 0;
765	}
766	return 1;
767	}
768
769	the_event->err_msg =
770	strdup( "Global error. usePeriodicBoundaryConditions was not \"true\" or \"false\".\n" );
771	return 0;
772	break;
773
774	case G_USERF:
775	if( the_type == STRING ){
776
777	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	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	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
821	}
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	}