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 |
115 |
< |
#define G_FORCEFIELD_FILENAME 53 |
116 |
< |
#define G_THERM_INT_DIST_SPRING 54 |
117 |
< |
#define G_THERM_INT_THETA_SPRING 55 |
118 |
< |
#define G_THERM_INT_OMEGA_SPRING 56 |
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(); |
129 |
|
|
130 |
|
Globals::~Globals(){ |
131 |
|
int i; |
126 |
– |
|
127 |
– |
for( i=0; i<hash_size; i++ ){ |
128 |
– |
if( command_table[i] != NULL ) delete command_table[i]; |
129 |
– |
} |
130 |
– |
delete[] command_table; |
131 |
– |
|
132 |
|
if( components != NULL ){ |
133 |
|
for( i=0; i<n_components; i++ ) delete components[i]; |
134 |
|
delete[] components; |
138 |
|
void Globals::initalize(){ |
139 |
|
int i; |
140 |
|
|
141 |
– |
hash_size = 23; |
142 |
– |
hash_shift = 4; |
143 |
– |
|
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); |
200 |
< |
addHash( "forceFieldFileName", G_FORCEFIELD_FILENAME); |
201 |
< |
addHash( "thermIntDistSpringConst", G_THERM_INT_DIST_SPRING); |
202 |
< |
addHash( "thermIntThetaSpringConst", G_THERM_INT_THETA_SPRING); |
203 |
< |
addHash( "thermIntOmegaSpringConst", G_THERM_INT_OMEGA_SPRING); |
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 |
210 |
– |
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; |
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; |
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 ){ |
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 |
|
|
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 ){ |
1131 |
|
|
1132 |
|
the_event->err_msg = |
1133 |
|
strdup( "Error in parsing meta-data file!\n\tusePeriodicBoundaryConditions was not \"true\" or \"false\".\n" ); |
1090 |
– |
return 0; |
1091 |
– |
break; |
1092 |
– |
|
1093 |
– |
case G_USERF: |
1094 |
– |
if( the_type == STRING ){ |
1095 |
– |
|
1096 |
– |
if( !strcasecmp( "true", the_event->evt.asmt.rhs.sval )) useRF = 1; |
1097 |
– |
else if( !strcasecmp( "false", the_event->evt.asmt.rhs.sval )) useRF = 0; |
1098 |
– |
else{ |
1099 |
– |
the_event->err_msg = |
1100 |
– |
strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" ); |
1101 |
– |
return 0; |
1102 |
– |
} |
1103 |
– |
return 1; |
1104 |
– |
} |
1105 |
– |
|
1106 |
– |
the_event->err_msg = |
1107 |
– |
strdup( "Error in parsing meta-data file!\n\tuseReactionField was not \"true\" or \"false\".\n" ); |
1134 |
|
return 0; |
1135 |
|
break; |
1136 |
|
|
1283 |
|
switch( the_type ){ |
1284 |
|
|
1285 |
|
case STRING: |
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 |
< |
} |
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 |
> |
} |
1292 |
|
have_zcons_force_policy = 1; |
1293 |
< |
return 1; |
1293 |
> |
return 1; |
1294 |
|
break; |
1295 |
|
|
1296 |
|
case DOUBLE: |
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 |
|
|
1844 |
|
} |
1845 |
|
break; |
1846 |
|
|
1847 |
< |
case G_THERM_INT_OMEGA_SPRING: |
1847 |
> |
case G_THERM_INT_OMEGA_SPRING: |
1848 |
|
switch( the_type ){ |
1849 |
|
|
1850 |
|
case STRING: |
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 |
|
} |
2136 |
|
return 1; |
2137 |
|
} |
2138 |
|
|
1940 |
– |
int Globals::hash( char* text ){ |
1941 |
– |
|
1942 |
– |
register unsigned short int i = 0; // loop counter |
1943 |
– |
int key = 0; // the hash key |
1944 |
– |
|
1945 |
– |
while( text[i] != '\0' ){ |
1946 |
– |
|
1947 |
– |
key = ( ( key << hash_shift ) + text[i] ) % hash_size; |
1948 |
– |
|
1949 |
– |
i++; |
1950 |
– |
} |
1951 |
– |
|
1952 |
– |
if( key < 0 ){ |
1953 |
– |
|
1954 |
– |
// if the key is less than zero, we've had an overflow error |
1955 |
– |
|
1956 |
– |
sprintf( painCave.errMsg, |
1957 |
– |
"There has been an overflow error in the Globals' hash key."); |
1958 |
– |
painCave.isFatal = 1; |
1959 |
– |
simError(); |
1960 |
– |
#ifdef IS_MPI |
1961 |
– |
if( painCave.isEventLoop ){ |
1962 |
– |
if( worldRank == 0 ) mpiInterfaceExit(); |
1963 |
– |
} |
1964 |
– |
#endif //is_mpi |
1965 |
– |
} |
1966 |
– |
|
1967 |
– |
return key; |
1968 |
– |
} |
1969 |
– |
|
1970 |
– |
void Globals::addHash( char* text, int token ){ |
1971 |
– |
|
1972 |
– |
int key; |
1973 |
– |
LinkedCommand* the_element; |
1974 |
– |
|
1975 |
– |
the_element = new LinkedCommand; |
1976 |
– |
the_element->setValues( text, token ); |
1977 |
– |
|
1978 |
– |
key = hash( text ); |
1979 |
– |
|
1980 |
– |
the_element->setNext( command_table[key] ); |
1981 |
– |
command_table[key] = the_element; |
1982 |
– |
} |