mdtools/interface_implementation/Globals.cpp

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

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

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

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

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


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

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

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

  addHash( "initialConfig", G_INITIALCONFIG );
  addHash( "finalConfig",   G_FINALCONFIG );
  addHash( "nMol",          G_NMOL );
  addHash( "density",       G_DENSITY );
  addHash( "box",           G_BOX );
  addHash( "boxX",          G_BOXX );
  addHash( "boxY",          G_BOXY );
  addHash( "boxZ",          G_BOXZ );
  addHash( "sampleTime",    G_SAMPLETIME );
  addHash( "statusTime",    G_STATUSTIME );
  addHash( "rRF",           G_RRF );
  addHash( "dielectric",    G_DIELECTRIC );
  addHash( "tempSet",       G_TEMPSET );
  addHash( "thermalTime",   G_THERMALTIME );
  addHash("mixingRule", G_MIXINGRULE);
  mixingRule = "standard"; //default mixing rules to standard.
  addHash("periodicBoundryConditions", G_USEPBC);
  usePBC = 1; //default  periodic boundry conditions to on
  

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

Globals::~Globals(){
  int i;

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

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

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


int Globals::componentAssign( event* the_event ){

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

int Globals::componentStartIndex( event* the_event ){

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

int Globals::componentEnd( event* the_event ){

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

  return 1;
}

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

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

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

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

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

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

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

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

  return 1;
}

int Globals::hash( char* text ){

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

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

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

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

  int key;
  LinkedCommand* the_element;

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

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