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> |
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 |
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(); |
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; |
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; |
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; |
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 ){ |
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" ); |
1038 |
– |
return 0; |
1039 |
– |
break; |
1040 |
– |
|
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" ); |
1134 |
|
return 0; |
1135 |
|
break; |
1136 |
|
|
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: |
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 |
|
|
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 |
|
|
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 |
|
|
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 ); |
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 |
|
} |
2051 |
|
|
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 |
– |
} |