ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/io/Globals.cpp
(Generate patch)

Comparing trunk/src/io/Globals.cpp (file contents):
Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 629 by chuckv, Mon Sep 26 15:58:17 2005 UTC

# Line 1 | Line 1
1 + /*
2 + * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3 + *
4 + * The University of Notre Dame grants you ("Licensee") a
5 + * non-exclusive, royalty free, license to use, modify and
6 + * redistribute this software in source and binary code form, provided
7 + * that the following conditions are met:
8 + *
9 + * 1. Acknowledgement of the program authors must be made in any
10 + *    publication of scientific results based in part on use of the
11 + *    program.  An acceptable form of acknowledgement is citation of
12 + *    the article in which the program was described (Matthew
13 + *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 + *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 + *    Parallel Simulation Engine for Molecular Dynamics,"
16 + *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 + *
18 + * 2. Redistributions of source code must retain the above copyright
19 + *    notice, this list of conditions and the following disclaimer.
20 + *
21 + * 3. Redistributions in binary form must reproduce the above copyright
22 + *    notice, this list of conditions and the following disclaimer in the
23 + *    documentation and/or other materials provided with the
24 + *    distribution.
25 + *
26 + * This software is provided "AS IS," without a warranty of any
27 + * kind. All express or implied conditions, representations and
28 + * warranties, including any implied warranty of merchantability,
29 + * fitness for a particular purpose or non-infringement, are hereby
30 + * excluded.  The University of Notre Dame and its licensors shall not
31 + * be liable for any damages suffered by licensee as a result of
32 + * using, modifying or distributing the software or its
33 + * derivatives. In no event will the University of Notre Dame or its
34 + * licensors be liable for any lost revenue, profit or data, or for
35 + * direct, indirect, special, consequential, incidental or punitive
36 + * damages, however caused and regardless of the theory of liability,
37 + * arising out of the use of or inability to use software, even if the
38 + * University of Notre Dame has been advised of the possibility of
39 + * such damages.
40 + */
41 +
42   #include <stdlib.h>
43   #include <stdio.h>
44   #include <string.h>
45  
46 < #include "Globals.hpp"
47 < #include "simError.h"
46 > #include "io/Globals.hpp"
47 > #include "utils/simError.h"
48   #ifdef IS_MPI
49 < #include "mpiBASS.h"
49 > #include "io/mpiBASS.h"
50   #endif // is_mpi
51  
52   /*
53   * The following section lists all of the defined tokens for the
54 < * gloabal assignment statements. All are prefixed with a G_ to avoid
54 > * global assignment statements. All are prefixed with a G_ to avoid
55   * stepping on any previously defined enumerations.
56   *
57   * NOTE: tokens start at 1, 0 is a resrved token number
# Line 42 | Line 83
83   #define G_THERMALTIME       21
84   #define G_USEPBC            22
85   #define G_MIXINGRULE        23
86 < #define G_USERF             24
87 < #define G_TARGETPRESSURE    25
88 < #define G_TAUTHERMOSTAT     26
89 < #define G_TAUBAROSTAT       27
90 < #define G_ZCONSTIME         28
91 < #define G_NZCONSTRAINTS     29
92 < #define G_ZCONSTOL          30
93 < #define G_ZCONSFORCEPOLICY  31
94 < #define G_SEED              32
95 < #define G_RESETTIME         33
96 < #define G_USEINITTIME       34
97 < #define G_USEINIT_XS_STATE  35
98 < #define G_ORTHOBOXTOLERANCE 36
99 < #define G_MINIMIZER         37
100 < #define G_MIN_MAXITER       38
101 < #define G_MIN_WRITEFRQ      39
102 < #define G_MIN_STEPSIZE      40
103 < #define G_MIN_FTOL          41
104 < #define G_MIN_GTOL          42
105 < #define G_MIN_LSTOL         43
106 < #define G_MIN_LSMAXITER     44
107 < #define G_ZCONSGAP          45
108 < #define G_ZCONSFIXTIME      46
109 < #define G_ZCONSUSINGSMD     47
110 < #define G_USE_SOLID_THERM_INT     48
111 < #define G_USE_LIQUID_THERM_INT    49
112 < #define G_THERM_INT_LAMBDA  50
113 < #define G_THERM_INT_K       51
114 < #define G_FORCEFIELD_VARIANT 52
86 > #define G_TARGETPRESSURE    24
87 > #define G_TAUTHERMOSTAT     25
88 > #define G_TAUBAROSTAT       26
89 > #define G_ZCONSTIME         27
90 > #define G_NZCONSTRAINTS     28
91 > #define G_ZCONSTOL          29
92 > #define G_ZCONSFORCEPOLICY  30
93 > #define G_SEED              31
94 > #define G_RESETTIME         32
95 > #define G_USEINITTIME       33
96 > #define G_USEINIT_XS_STATE  34
97 > #define G_ORTHOBOXTOLERANCE 35
98 > #define G_MINIMIZER         36
99 > #define G_MIN_MAXITER       37
100 > #define G_MIN_WRITEFRQ      38
101 > #define G_MIN_STEPSIZE      39
102 > #define G_MIN_FTOL          40
103 > #define G_MIN_GTOL          41
104 > #define G_MIN_LSTOL         42
105 > #define G_MIN_LSMAXITER     43
106 > #define G_ZCONSGAP          44
107 > #define G_ZCONSFIXTIME      45
108 > #define G_ZCONSUSINGSMD     46
109 > #define G_USE_SOLID_THERM_INT    47
110 > #define G_USE_LIQUID_THERM_INT   48
111 > #define G_THERM_INT_LAMBDA  49
112 > #define G_THERM_INT_K       50
113 > #define G_FORCEFIELD_VARIANT     51
114 > #define G_FORCEFIELD_FILENAME    52
115 > #define G_THERM_INT_DIST_SPRING  53
116 > #define G_THERM_INT_THETA_SPRING 54
117 > #define G_THERM_INT_OMEGA_SPRING 55
118 > #define G_SURFACETENSION    56
119 > #define G_PRINTPRESSURETENSOR    57
120 > #define G_ELECTRO_SUM_METHOD     58
121 > #define G_DAMPING_ALPHA     59
122 > #define G_CUTOFFPOLICY      60
123 > #define G_COMPRESSDUMPFILE  61
124 > #define G_SKINTHICKNESS     62
125  
126   Globals::Globals(){
127    initalize();
# Line 78 | Line 129 | Globals::~Globals(){
129  
130   Globals::~Globals(){
131    int i;
81 –
82 –  for( i=0; i<hash_size; i++ ){
83 –    if( command_table[i] != NULL ) delete command_table[i];
84 –  }
85 –  delete[] command_table;
86 –
132    if( components != NULL ){
133      for( i=0; i<n_components; i++ ) delete components[i];
134      delete[] components;
# Line 93 | Line 138 | void Globals::initalize(){
138   void Globals::initalize(){
139    int i;
140    
96 –  hash_size = 23;
97 –  hash_shift = 4;
98 –  
141    components = NULL;
142    
143 <  command_table = new LinkedCommand*[hash_size];
144 <  for( i=0; i<hash_size; i++ ) command_table[i] = NULL;
145 <  
146 <  addHash( "forceField",    G_FORCEFIELD );
147 <  addHash( "nComponents",   G_NCOMPONENTS );
148 <  addHash( "targetTemp",    G_TARGETTEMP );
149 <  addHash( "ensemble",      G_ENSEMBLE );
150 <  
151 <  addHash( "dt",            G_DT );
152 <  addHash( "runTime",       G_RUNTIME );
153 <  
154 <  addHash( "initialConfig", G_INITIALCONFIG );
155 <  addHash( "finalConfig",   G_FINALCONFIG );
156 <  addHash( "nMol",          G_NMOL );
157 <  addHash( "density",       G_DENSITY );
158 <  addHash( "box",           G_BOX );
159 <  addHash( "boxX",          G_BOXX );
160 <  addHash( "boxY",          G_BOXY );
161 <  addHash( "boxZ",          G_BOXZ );
162 <  addHash( "sampleTime",    G_SAMPLETIME );
163 <  addHash( "resetTime",     G_RESETTIME );
164 <  addHash( "statusTime",    G_STATUSTIME );
165 <  addHash( "cutoffRadius",  G_RCUT );
166 <  addHash( "switchingRadius",  G_RSW );
167 <  addHash( "dielectric",    G_DIELECTRIC );
168 <  addHash( "tempSet",       G_TEMPSET );
169 <  addHash( "thermalTime",   G_THERMALTIME );
170 <  addHash( "mixingRule",    G_MIXINGRULE);
171 <  addHash( "usePeriodicBoundaryConditions",        G_USEPBC);
172 <  addHash( "useReactionField",                     G_USERF );
173 <  addHash( "targetPressure",                       G_TARGETPRESSURE);
174 <  addHash( "tauThermostat",                        G_TAUTHERMOSTAT);
175 <  addHash( "tauBarostat",                          G_TAUBAROSTAT);
176 <  addHash( "zconsTime",                            G_ZCONSTIME);
177 <  addHash( "nZconstraints",                        G_NZCONSTRAINTS);
178 <  addHash( "zconsTol",                             G_ZCONSTOL);
179 <  addHash( "zconsForcePolicy",                     G_ZCONSFORCEPOLICY);
180 <  addHash( "seed",                                 G_SEED);
181 <  addHash( "useInitialTime",                       G_USEINITTIME);
182 <  addHash( "useInitialExtendedSystemState",        G_USEINIT_XS_STATE);
183 <  addHash( "orthoBoxTolerance",                    G_ORTHOBOXTOLERANCE);
184 <  addHash( "minimizer",                            G_MINIMIZER);
185 <  addHash( "minimizerMaxIter",                     G_MIN_MAXITER);
186 <  addHash( "minimizerWriteFrq",                    G_MIN_WRITEFRQ);
187 <  addHash( "minimizerStepSize",                    G_MIN_STEPSIZE);
188 <  addHash( "minimizerFTol",                        G_MIN_FTOL);
189 <  addHash( "minimizerGTol",                        G_MIN_GTOL);
190 <  addHash( "minimizerLSTol",                       G_MIN_LSTOL);
191 <  addHash( "minimizerLSMaxIter",                   G_MIN_LSMAXITER);
192 <  addHash( "zconsGap",                             G_ZCONSGAP);
193 <  addHash( "zconsFixtime",                         G_ZCONSFIXTIME);
194 <  addHash( "zconsUsingSMD",                        G_ZCONSUSINGSMD);
195 <  addHash( "useSolidThermInt",                     G_USE_SOLID_THERM_INT);
196 <  addHash( "useLiquidThermInt",                    G_USE_LIQUID_THERM_INT);
197 <  addHash( "thermodynamicIntegrationLambda",       G_THERM_INT_LAMBDA);
198 <  addHash( "thermodynamicIntegrationK",            G_THERM_INT_K);
199 <  addHash( "forceFieldVariant",                    G_FORCEFIELD_VARIANT);
143 >  command_table.insert(CommandMapType::value_type("forceField", G_FORCEFIELD));
144 >  command_table.insert(CommandMapType::value_type("nComponents", G_NCOMPONENTS));
145 >  command_table.insert(CommandMapType::value_type("targetTemp", G_TARGETTEMP));
146 >  command_table.insert(CommandMapType::value_type("ensemble", G_ENSEMBLE));
147 >  command_table.insert(CommandMapType::value_type("dt", G_DT));
148 >  command_table.insert(CommandMapType::value_type("runTime", G_RUNTIME));
149 >  command_table.insert(CommandMapType::value_type("initialConfig", G_INITIALCONFIG));
150 >  command_table.insert(CommandMapType::value_type("finalConfig", G_FINALCONFIG));
151 >  command_table.insert(CommandMapType::value_type("nMol", G_NMOL));
152 >  command_table.insert(CommandMapType::value_type("density", G_DENSITY));
153 >  command_table.insert(CommandMapType::value_type("box", G_BOX));
154 >  command_table.insert(CommandMapType::value_type("boxX", G_BOXX));
155 >  command_table.insert(CommandMapType::value_type("boxY", G_BOXY));
156 >  command_table.insert(CommandMapType::value_type("boxZ", G_BOXZ));
157 >  command_table.insert(CommandMapType::value_type("sampleTime", G_SAMPLETIME));
158 >  command_table.insert(CommandMapType::value_type("resetTime", G_RESETTIME));
159 >  command_table.insert(CommandMapType::value_type("statusTime", G_STATUSTIME));
160 >  command_table.insert(CommandMapType::value_type("cutoffRadius", G_RCUT));
161 >  command_table.insert(CommandMapType::value_type("switchingRadius", G_RSW));
162 >  command_table.insert(CommandMapType::value_type("dielectric", G_DIELECTRIC));
163 >  command_table.insert(CommandMapType::value_type("tempSet", G_TEMPSET));
164 >  command_table.insert(CommandMapType::value_type("thermalTime", G_THERMALTIME));
165 >  command_table.insert(CommandMapType::value_type("mixingRule", G_MIXINGRULE));
166 >  command_table.insert(CommandMapType::value_type("usePeriodicBoundaryConditions", G_USEPBC));
167 >  command_table.insert(CommandMapType::value_type("targetPressure", G_TARGETPRESSURE));
168 >  command_table.insert(CommandMapType::value_type("tauThermostat", G_TAUTHERMOSTAT));
169 >  command_table.insert(CommandMapType::value_type("tauBarostat", G_TAUBAROSTAT));
170 >  command_table.insert(CommandMapType::value_type("zconsTime", G_ZCONSTIME));
171 >  command_table.insert(CommandMapType::value_type("nZconstraints", G_NZCONSTRAINTS));
172 >  command_table.insert(CommandMapType::value_type("zconsTol", G_ZCONSTOL));
173 >  command_table.insert(CommandMapType::value_type("zconsForcePolicy", G_ZCONSFORCEPOLICY));
174 >  command_table.insert(CommandMapType::value_type("seed", G_SEED));
175 >  command_table.insert(CommandMapType::value_type("useInitialTime", G_USEINITTIME));
176 >  command_table.insert(CommandMapType::value_type("useInitialExtendedSystemState", G_USEINIT_XS_STATE));
177 >  command_table.insert(CommandMapType::value_type("orthoBoxTolerance", G_ORTHOBOXTOLERANCE));
178 >  command_table.insert(CommandMapType::value_type("minimizer", G_MINIMIZER));
179 >  command_table.insert(CommandMapType::value_type("minimizerMaxIter", G_MIN_MAXITER));
180 >  command_table.insert(CommandMapType::value_type("minimizerWriteFrq", G_MIN_WRITEFRQ));
181 >  command_table.insert(CommandMapType::value_type("minimizerStepSize", G_MIN_STEPSIZE));
182 >  command_table.insert(CommandMapType::value_type("minimizerFTol", G_MIN_FTOL));
183 >  command_table.insert(CommandMapType::value_type("minimizerGTol", G_MIN_GTOL));
184 >  command_table.insert(CommandMapType::value_type("minimizerLSTol", G_MIN_LSTOL));
185 >  command_table.insert(CommandMapType::value_type("minimizerLSMaxIter", G_MIN_LSMAXITER));
186 >  command_table.insert(CommandMapType::value_type("zconsGap", G_ZCONSGAP));
187 >  command_table.insert(CommandMapType::value_type("zconsFixtime", G_ZCONSFIXTIME));
188 >  command_table.insert(CommandMapType::value_type("zconsUsingSMD", G_ZCONSUSINGSMD));
189 >  command_table.insert(CommandMapType::value_type("useSolidThermInt", G_USE_SOLID_THERM_INT));
190 >  command_table.insert(CommandMapType::value_type("useLiquidThermInt", G_USE_LIQUID_THERM_INT));
191 >  command_table.insert(CommandMapType::value_type("thermodynamicIntegrationLambda", G_THERM_INT_LAMBDA));
192 >  command_table.insert(CommandMapType::value_type("thermodynamicIntegrationK", G_THERM_INT_K));
193 >  command_table.insert(CommandMapType::value_type("forceFieldVariant", G_FORCEFIELD_VARIANT));
194 >  command_table.insert(CommandMapType::value_type("forceFieldFileName", G_FORCEFIELD_FILENAME));
195 >  command_table.insert(CommandMapType::value_type("thermIntDistSpringConst", G_THERM_INT_DIST_SPRING));
196 >  command_table.insert(CommandMapType::value_type("thermIntThetaSpringConst", G_THERM_INT_THETA_SPRING));
197 >  command_table.insert(CommandMapType::value_type("thermIntOmegaSpringConst", G_THERM_INT_OMEGA_SPRING));
198 >  command_table.insert(CommandMapType::value_type("surfaceTension", G_SURFACETENSION));
199 >  command_table.insert(CommandMapType::value_type("printPressureTensor", G_PRINTPRESSURETENSOR));
200 >  command_table.insert(CommandMapType::value_type("electrostaticSummationMethod", G_ELECTRO_SUM_METHOD));
201 >  command_table.insert(CommandMapType::value_type("dampingAlpha", G_DAMPING_ALPHA));
202 >  command_table.insert(CommandMapType::value_type("cutoffPolicy", G_CUTOFFPOLICY));
203 >  command_table.insert(CommandMapType::value_type("compressDumpFile", G_COMPRESSDUMPFILE));
204 >  command_table.insert(CommandMapType::value_type("skinThickness", G_SKINTHICKNESS));
205  
206    strcpy( mixingRule,"standard");  //default mixing rules to standard.
207    usePBC = 1; //default  periodic boundry conditions to on
161 –  useRF  = 0;
208    useInitTime = 0; // default to pull init time from the init file
209    useInitXSstate = 0; // default to pull the extended state from the init file
210    orthoBoxTolerance = 1E-6;
211    useSolidThermInt = 0; // default solid-state thermodynamic integration to off
212    useLiquidThermInt = 0; // default liquid thermodynamic integration to off
213 +  dampingAlpha = 1.5; // default damping parameter in Wolf Electrostatics
214 +  compressDumpFile = 0; // default compressDumpFile set to off
215 +  skinThickness = 1.0; // default neighborlist skin thickness is one angstrom
216  
217    have_force_field =  0;
218    have_n_components = 0;
# Line 172 | Line 221 | void Globals::initalize(){
221    have_dt =           0;
222    have_run_time =     0;
223    
224 +  have_skin_thickness = 0;
225    have_initial_config = 0;
226    have_final_config =   0;
227    have_n_mol =          0;
# Line 212 | Line 262 | void Globals::initalize(){
262    have_thermodynamic_integration_lambda = 0;
263    have_thermodynamic_integration_k = 0;
264    have_forcefield_variant = 0;
265 <
265 >  have_forcefield_filename = 0;
266 >  have_dist_spring_constant =  0;
267 >  have_theta_spring_constant = 0;
268 >  have_omega_spring_constant = 0;
269 >  have_surface_tension = 0;
270 >  have_print_pressure_tensor = 0;
271 >  have_electro_sum_method = 0;
272 >  have_damping_alpha = 0;
273 >  have_cutoff_policy = 0;
274 >  have_compress_dumpfile = 0;
275   }
276  
277   int Globals::newComponent( event* the_event ){
# Line 360 | Line 419 | int Globals::globalAssign( event* the_event ){
419    char err[300];
420    
421    token = 0;
422 <  key = hash( lhs );
423 <  if( command_table[key] != NULL ) token = command_table[key]->match( lhs );
422 >
423 >  CommandMapType::iterator iter;
424 >  std::string keyword(lhs);
425 >  iter = command_table.find(keyword);
426 >  if (iter != command_table.end()) {
427 >    token = iter->second;
428 >  }
429    
430    if( token ){
431      
# Line 929 | Line 993 | int Globals::globalAssign( event* the_event ){
993        default:
994          the_event->err_msg =
995            strdup( "Error in parsing meta-data file!\n\tswitchingRadius unrecognized.\n" );
996 +        return 0;
997 +        break;
998 +      }
999 +      break;
1000 +
1001 +
1002 +    case G_SKINTHICKNESS:
1003 +      switch( the_type ){
1004 +        
1005 +      case STRING:
1006 +        the_event->err_msg =
1007 +          strdup( "Error in parsing meta-data file!\n\tskinThickness is not a double or int.\n" );
1008 +        return 0;
1009 +        break;
1010 +        
1011 +      case DOUBLE:
1012 +        skinThickness = the_event->evt.asmt.rhs.dval;
1013 +        have_skin_thickness = 1;
1014 +        return 1;
1015 +        break;
1016 +        
1017 +      case INT:
1018 +        skinThickness = (double)the_event->evt.asmt.rhs.ival;
1019 +        have_skin_thickness = 1;
1020 +        return 1;
1021 +        break;
1022 +        
1023 +      default:
1024 +        the_event->err_msg =
1025 +          strdup( "Error in parsing meta-data file!\n\tskinThickness unrecognized.\n" );
1026          return 0;
1027          break;
1028        }
1029        break;
1030 +
1031 +
1032        
1033      case G_DIELECTRIC:
1034        switch( the_type ){
# Line 1038 | Line 1134 | int Globals::globalAssign( event* the_event ){
1134        return 0;
1135        break;
1136  
1041 –    case G_USERF:
1042 –      if( the_type == STRING ){
1043 –        
1044 –        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1;
1045 –        else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0;
1046 –        else{
1047 –          the_event->err_msg =
1048 –            strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" );
1049 –          return 0;
1050 –        }
1051 –        return 1;
1052 –      }
1053 –      
1054 –      the_event->err_msg =
1055 –        strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" );
1056 –      return 0;
1057 –      break;
1058 –
1137      case G_TARGETPRESSURE:
1138        switch( the_type ){
1139          
# Line 1205 | Line 1283 | int Globals::globalAssign( event* the_event ){
1283        switch( the_type ){
1284          
1285        case STRING:
1286 <   strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1286 >        strcpy(zconsForcePolicy, the_event->evt.asmt.rhs.sval);
1287  
1288 <   for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1289 <        {
1290 <      zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1291 <   }
1288 >        for(int i = 0; zconsForcePolicy[i] != '\0'; i++)
1289 >          {
1290 >            zconsForcePolicy[i] = toupper(zconsForcePolicy[i]);
1291 >          }
1292          have_zcons_force_policy = 1;
1293 <   return 1;
1293 >        return 1;
1294          break;
1295          
1296        case DOUBLE:
# Line 1389 | Line 1467 | int Globals::globalAssign( event* the_event ){
1467  
1468        case STRING:
1469          the_event->err_msg =
1470 <          strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not a double or int.\n" );
1470 >          strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not an int.\n" );
1471          return 1;
1472          break;
1473          
1474        case DOUBLE:
1475 <        minimizer_writefrq= the_event->evt.asmt.rhs.dval;
1476 <        have_minimizer_writefrq = 1;
1475 >        the_event->err_msg =
1476 >          strdup( "Error in parsing meta-data file!\n\tminimizer_writefrq is not an  int.\n" );
1477          return 1;
1478          break;
1479          
# Line 1505 | Line 1583 | int Globals::globalAssign( event* the_event ){
1583  
1584        case STRING:
1585          the_event->err_msg =
1586 <          strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not a double or int.\n" );
1586 >          strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not an int.\n" );
1587          return 1;
1588          break;
1589          
1590        case DOUBLE:
1591 <        minimizer_ls_maxiteration = the_event->evt.asmt.rhs.dval;
1592 <        have_minimizer_ls_maxiteration = 1;
1591 >        the_event->err_msg =
1592 >          strdup( "Error in parsing meta-data file!\n\tminimizer_ls_maxiteration is not an int.\n" );
1593          return 1;
1594          break;
1595          
# Line 1563 | Line 1641 | int Globals::globalAssign( event* the_event ){
1641        switch( the_type ){
1642          
1643        case STRING:
1644 <   the_event->err_msg =
1644 >        the_event->err_msg =
1645            strdup( "Error in parsing meta-data file!\n\tseed is not a string.\n" );
1646          return 0;
1647 <   return 0;
1647 >        return 0;
1648          break;
1649          
1650        case DOUBLE:
1651 <   have_seed = 1;
1652 <   seed = (int)the_event->evt.asmt.rhs.dval;
1651 >        have_seed = 1;
1652 >        seed = (int)the_event->evt.asmt.rhs.dval;
1653          return 1;
1654          break;
1655          
1656        case INT:
1657 <   have_seed = 1;
1658 <   seed =  the_event->evt.asmt.rhs.ival ;
1657 >        have_seed = 1;
1658 >        seed =  the_event->evt.asmt.rhs.ival ;
1659          return 1;
1660          break;
1661          
# Line 1681 | Line 1759 | int Globals::globalAssign( event* the_event ){
1759          return 0;
1760          break;
1761        }
1762 <      break;      
1762 >      break;  
1763 >  
1764      case G_FORCEFIELD_VARIANT:
1765        if( the_type == STRING ){
1766          strcpy( forcefield_variant, the_event->evt.asmt.rhs.sval );
# Line 1693 | Line 1772 | int Globals::globalAssign( event* the_event ){
1772          strdup( "Error in parsing meta-data file!\n\tforceFieldVariant was not a string assignment.\n" );
1773        return 0;
1774        break;      
1775 +      // add more token cases here.      
1776 +
1777 +    case G_FORCEFIELD_FILENAME:
1778 +      if( the_type == STRING ){
1779 +        strcpy( forcefield_filename, the_event->evt.asmt.rhs.sval );
1780 +        have_forcefield_filename = 1;
1781 +        return 1;
1782 +      }
1783 +      
1784 +      the_event->err_msg =
1785 +        strdup( "Error in parsing meta-data file!\n\tforceFieldFileName was not a string assignment.\n" );
1786 +      return 0;
1787 +      break;      
1788 +
1789 +    case G_THERM_INT_DIST_SPRING:
1790 +      switch( the_type ){
1791 +        
1792 +      case STRING:
1793 +        the_event->err_msg =
1794 +          strdup( "Error in parsing meta-data file!\n\tthermIntDistSpringConst is not a double or int.\n" );
1795 +        return 1;
1796 +        break;
1797 +        
1798 +      case DOUBLE:
1799 +        therm_int_dist_spring = the_event->evt.asmt.rhs.dval;
1800 +        have_dist_spring_constant = 1;
1801 +        return 1;
1802 +        break;
1803 +        
1804 +      case INT:
1805 +        therm_int_dist_spring = (double)the_event->evt.asmt.rhs.dval;
1806 +        have_dist_spring_constant = 1;
1807 +        return 1;
1808 +        break;
1809 +        
1810 +      default:
1811 +        the_event->err_msg =
1812 +          strdup( "Error in parsing meta-data file!\n\tthermIntDistSpringConst unrecognized.\n" );
1813 +        return 0;
1814 +        break;
1815 +      }
1816 +      break;  
1817 +
1818 +    case G_THERM_INT_THETA_SPRING:
1819 +      switch( the_type ){
1820 +        
1821 +      case STRING:
1822 +        the_event->err_msg =
1823 +          strdup( "Error in parsing meta-data file!\n\tthermIntThetaSpringConst is not a double or int.\n" );
1824 +        return 1;
1825 +        break;
1826 +        
1827 +      case DOUBLE:
1828 +        therm_int_theta_spring = the_event->evt.asmt.rhs.dval;
1829 +        have_theta_spring_constant = 1;
1830 +        return 1;
1831 +        break;
1832 +        
1833 +      case INT:
1834 +        therm_int_theta_spring = (double)the_event->evt.asmt.rhs.dval;
1835 +        have_theta_spring_constant = 1;
1836 +        return 1;
1837 +        break;
1838 +        
1839 +      default:
1840 +        the_event->err_msg =
1841 +          strdup( "Error in parsing meta-data file!\n\tthermIntThetaSpringConst unrecognized.\n" );
1842 +        return 0;
1843 +        break;
1844 +      }
1845 +      break;
1846 +
1847 +    case G_THERM_INT_OMEGA_SPRING:
1848 +      switch( the_type ){
1849 +        
1850 +      case STRING:
1851 +        the_event->err_msg =
1852 +          strdup( "Error in parsing meta-data file!\n\tthermIntOmegaSpringConst is not a double or int.\n" );
1853 +        return 1;
1854 +        break;
1855 +        
1856 +      case DOUBLE:
1857 +        therm_int_omega_spring = the_event->evt.asmt.rhs.dval;
1858 +        have_omega_spring_constant = 1;
1859 +        return 1;
1860 +        break;
1861 +        
1862 +      case INT:
1863 +        therm_int_omega_spring = (double)the_event->evt.asmt.rhs.dval;
1864 +        have_omega_spring_constant = 1;
1865 +        return 1;
1866 +        break;
1867 +        
1868 +      default:
1869 +        the_event->err_msg =
1870 +          strdup( "Error in parsing meta-data file!\n\tthermIntOmegaSpringConst unrecognized.\n" );
1871 +        return 0;
1872 +        break;
1873 +      }
1874 +      break;  
1875 +
1876 +    case G_SURFACETENSION:
1877 +        switch( the_type ){
1878 +      
1879 +        case STRING:
1880 +          the_event->err_msg =
1881 +            strdup( "Error in parsing meta-data file!\n\tsurfaceTension is not a double or int.\n" );
1882 +          return 1;
1883 +          break;
1884 +          
1885 +        case DOUBLE:
1886 +          surface_tension= the_event->evt.asmt.rhs.dval;
1887 +          have_surface_tension = 1;
1888 +          return 1;
1889 +          break;
1890 +          
1891 +        case INT:
1892 +          surface_tension = (double)the_event->evt.asmt.rhs.dval;
1893 +          have_surface_tension = 1;
1894 +          return 1;
1895 +          break;
1896 +          
1897 +        default:
1898 +          the_event->err_msg =
1899 +            strdup( "Error in parsing meta-data file!\n\tsurfaceTension unrecognized.\n" );
1900 +          return 0;
1901 +          break;
1902 +        }
1903 +        break;
1904 +
1905 +    case G_PRINTPRESSURETENSOR:
1906 +      if( the_type == STRING ){
1907 +        
1908 +        if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) {
1909 +            have_print_pressure_tensor= 1;
1910 +            print_pressure_tensor = 1;
1911 +        } else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) {
1912 +            have_print_pressure_tensor= 1;
1913 +            print_pressure_tensor = 0;
1914 +        } else{
1915 +          the_event->err_msg =
1916 +            strdup( "Error in parsing meta-data file!\n\tprintPressureTensor was not \"true\" or \"false\".\n" );
1917 +          return 0;
1918 +        }
1919 +        return 1;
1920 +          }
1921 +          
1922 +          the_event->err_msg =
1923 +        strdup( "Error in parsing meta-data file!\n\tprintPressureTensor was not \"true\" or \"false\".\n" );
1924 +          return 0;
1925 +          break;
1926 +
1927 +    case G_COMPRESSDUMPFILE:
1928 +       if( the_type == STRING ){
1929 +          
1930 +          if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) {
1931 +             have_compress_dumpfile = 1;
1932 +             compressDumpFile = 1;
1933 +          } else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) {
1934 +             have_compress_dumpfile= 1;
1935 +             compressDumpFile = 0;
1936 +          } else{
1937 +             the_event->err_msg =
1938 +             strdup( "Error in parsing meta-data file!\n\tcompressDumpFile was not \"true\" or \"false\".\n" );
1939 +             return 0;
1940 +          }
1941 +          return 1;
1942 +       }
1943 +      
1944 +       the_event->err_msg =
1945 +       strdup( "Error in parsing meta-data file!\n\tcompressDumpFile was not \"true\" or \"false\".\n" );
1946 +       return 0;
1947 +       break;
1948 +      
1949 +      
1950 +    case G_ELECTRO_SUM_METHOD:
1951 +      switch( the_type ){
1952 +        
1953 +      case STRING:
1954 +        strcpy(electrostaticSummationMethod, the_event->evt.asmt.rhs.sval);
1955 +
1956 +        for(int i = 0; electrostaticSummationMethod[i] != '\0'; i++)
1957 +          {
1958 +            electrostaticSummationMethod[i] = toupper(electrostaticSummationMethod[i]);
1959 +          }
1960 +        have_electro_sum_method = 1;
1961 +        return 1;
1962 +        break;
1963 +        
1964 +      case DOUBLE:
1965 +        the_event->err_msg =
1966 +          strdup( "Error in parsing meta-data file!\n\telectrostaticSummationMethod should be a string!\n" );
1967 +        return 0;
1968 +        break;
1969 +        
1970 +      case INT:
1971 +        the_event->err_msg =
1972 +          strdup( "Error in parsing meta-data file!\n\telectrostaticSummationMethod should be a string!\n" );
1973 +        return 0;
1974 +        break;
1975 +        
1976 +      default:
1977 +        the_event->err_msg =
1978 +          strdup( "Error in parsing meta-data file!\n\telectrostaticSummationMethod unrecognized.\n" );
1979 +        return 0;
1980 +        break;
1981 +      }
1982 +      break;
1983 +
1984 +    case G_DAMPING_ALPHA:
1985 +      switch( the_type ){
1986 +        
1987 +      case STRING:
1988 +        the_event->err_msg =
1989 +          strdup( "Error in parsing meta-data file!\n\tdampingAlpha is not a double or int.\n" );
1990 +        return 1;
1991 +        break;
1992 +        
1993 +      case DOUBLE:
1994 +        dampingAlpha = the_event->evt.asmt.rhs.dval;
1995 +        have_damping_alpha = 1;
1996 +        return 1;
1997 +        break;
1998 +        
1999 +      case INT:
2000 +        dampingAlpha = (double)the_event->evt.asmt.rhs.dval;
2001 +        have_damping_alpha = 1;
2002 +        return 1;
2003 +        break;
2004 +        
2005 +      default:
2006 +        the_event->err_msg =
2007 +          strdup( "Error in parsing meta-data file!\n\tdampingAlpha unrecognized.\n" );
2008 +        return 0;
2009 +        break;
2010 +      }
2011 +      break;  
2012 +
2013 +    case G_CUTOFFPOLICY:
2014 +      switch( the_type ){
2015 +        
2016 +      case STRING:
2017 +        strcpy(cutoffPolicy, the_event->evt.asmt.rhs.sval);
2018 +
2019 +        for(int i = 0; cutoffPolicy[i] != '\0'; i++)
2020 +          {
2021 +            cutoffPolicy[i] = toupper(cutoffPolicy[i]);
2022 +          }
2023 +        have_cutoff_policy = 1;
2024 +        return 1;
2025 +        break;
2026 +        
2027 +      case DOUBLE:
2028 +        the_event->err_msg =
2029 +          strdup( "Error in parsing meta-data file!\n\tcutoffPolicy should be a string!\n" );
2030 +        return 0;
2031 +        break;
2032 +        
2033 +      case INT:
2034 +        the_event->err_msg =
2035 +          strdup( "Error in parsing meta-data file!\n\tcutoffPolicy should be a string!\n" );
2036 +        return 0;
2037 +        break;
2038 +        
2039 +      default:
2040 +        the_event->err_msg =
2041 +          strdup( "Error in parsing meta-data file!\n\tcutoffPolicy unrecognized.\n" );
2042 +        return 0;
2043 +        break;
2044 +      }
2045 +      break;
2046 +
2047 +      
2048        // add more token cases here.      
2049      }
2050    }
# Line 1784 | Line 2136 | int Globals::globalEnd( event* the_event ){
2136    return 1;
2137   }
2138  
1787 – int Globals::hash( char* text ){
1788 –
1789 –  register unsigned short int i = 0; // loop counter
1790 –  int key = 0; // the hash key
1791 –  
1792 –  while( text[i] != '\0' ){
1793 –    
1794 –    key = ( ( key << hash_shift ) + text[i] ) % hash_size;
1795 –    
1796 –    i++;
1797 –  }
1798 –  
1799 –  if( key < 0 ){
1800 –
1801 –    // if the key is less than zero, we've had an overflow error
1802 –
1803 –    sprintf( painCave.errMsg,
1804 –             "There has been an overflow error in the Globals' hash key.");
1805 –    painCave.isFatal = 1;
1806 –    simError();
1807 – #ifdef IS_MPI
1808 –    if( painCave.isEventLoop ){
1809 –      if( worldRank == 0 ) mpiInterfaceExit();
1810 –    }
1811 – #endif //is_mpi
1812 –  }
1813 –  
1814 –  return key;
1815 – }
1816 –
1817 – void Globals::addHash( char* text, int token ){
1818 –
1819 –  int key;
1820 –  LinkedCommand* the_element;
1821 –
1822 –  the_element = new LinkedCommand;
1823 –  the_element->setValues( text, token );
1824 –
1825 –  key = hash( text );
1826 –
1827 –  the_element->setNext( command_table[key] );
1828 –  command_table[key] = the_element;
1829 – }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines