# | Line 45 | Line 45 | |
---|---|---|
45 | #include <string> | |
46 | ||
47 | #include "io/Globals.hpp" | |
48 | + | #include "io/ParamConstraint.hpp" |
49 | + | #include "utils/MemoryUtils.hpp" |
50 | #include "utils/simError.h" | |
49 | – | #ifdef IS_MPI |
50 | – | #include "io/mpiBASS.h" |
51 | – | #endif // is_mpi |
51 | ||
52 | < | #include "io/ParamConstraint.hpp" |
53 | < | |
55 | < | #define DefineParameter(NAME,KEYWORD) \ |
56 | < | NAME.setKeyword(KEYWORD); \ |
57 | < | parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME)); |
58 | < | |
59 | < | #define DefineOptionalParameter(NAME,KEYWORD) \ |
60 | < | NAME.setKeyword(KEYWORD); NAME.setOptional(true); \ |
61 | < | parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME)); |
62 | < | |
63 | < | #define DefineOptionalParameterWithDefaultValue(NAME,KEYWORD, DEFAULTVALUE) \ |
64 | < | NAME.setKeyword(KEYWORD); NAME.setOptional(true); NAME.setDefaultValue(DEFAULTVALUE); \ |
65 | < | parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME)); |
66 | < | |
67 | < | #define CheckParameter(NAME, CONSTRAINT) \ |
68 | < | if (!NAME.empty()) { if (!(CONSTRAINT)(NAME.getData())) { sprintf(painCave.errMsg,"Error in checking %s : should be %s\n",NAME.getKeyword().c_str(),(CONSTRAINT).getConstraintDescription().c_str()); painCave.isFatal = 1; painCave.severity = OOPSE_ERROR; simError();} } |
69 | < | |
70 | < | Globals::Globals(){ |
71 | < | |
52 | > | namespace oopse { |
53 | > | Globals::Globals() { |
54 | DefineParameter(ForceField, "forceField") | |
73 | – | DefineParameter(NComponents, "nComponents") |
55 | ||
56 | DefineOptionalParameter(TargetTemp, "targetTemp"); | |
57 | DefineOptionalParameter(Ensemble, "ensemble"); | |
58 | DefineOptionalParameter(Dt, "dt"); | |
59 | DefineOptionalParameter(RunTime, "runTime"); | |
79 | – | DefineOptionalParameter(InitialConfig, "initialConfig"); |
60 | DefineOptionalParameter(FinalConfig, "finalConfig"); | |
81 | – | DefineOptionalParameter(NMol, "nMol"); |
82 | – | DefineOptionalParameter(Density, "density"); |
83 | – | DefineOptionalParameter(Box, "box"); |
84 | – | DefineOptionalParameter(BoxX, "boxX"); |
85 | – | DefineOptionalParameter(BoxY, "boxY"); |
86 | – | DefineOptionalParameter(BoxZ, "boxZ"); |
61 | DefineOptionalParameter(SampleTime, "sampleTime"); | |
62 | DefineOptionalParameter(ResetTime, "resetTime"); | |
63 | DefineOptionalParameter(StatusTime, "statusTime"); | |
64 | DefineOptionalParameter(CutoffRadius, "cutoffRadius"); | |
65 | DefineOptionalParameter(SwitchingRadius, "switchingRadius"); | |
92 | – | DefineOptionalParameter(Dielectric, "dielectric"); |
66 | DefineOptionalParameter(TempSet, "tempSet"); | |
67 | DefineOptionalParameter(ThermalTime, "thermalTime"); | |
68 | < | DefineOptionalParameter(TargetPressure, "targetPressure"); |
68 | > | DefineOptionalParameter(TargetPressure, "targetPressure"); |
69 | DefineOptionalParameter(TauThermostat, "tauThermostat"); | |
70 | DefineOptionalParameter(TauBarostat, "tauBarostat"); | |
71 | DefineOptionalParameter(ZconsTime, "zconsTime"); | |
99 | – | DefineOptionalParameter(NZconstraints, "nZconstraints"); |
72 | DefineOptionalParameter(ZconsTol, "zconsTol"); | |
73 | DefineOptionalParameter(ZconsForcePolicy, "zconsForcePolicy"); | |
74 | DefineOptionalParameter(Seed, "seed"); | |
# | Line 115 | Line 87 | Globals::Globals(){ | |
87 | DefineOptionalParameter(ThermodynamicIntegrationK, "thermodynamicIntegrationK"); | |
88 | DefineOptionalParameter(ForceFieldVariant, "forceFieldVariant"); | |
89 | DefineOptionalParameter(ForceFieldFileName, "forceFieldFileName"); | |
90 | + | DefineOptionalParameter(DampingAlpha, "dampingAlpha"); |
91 | DefineOptionalParameter(ThermIntDistSpringConst, "thermIntDistSpringConst"); | |
92 | DefineOptionalParameter(ThermIntThetaSpringConst, "thermIntThetaSpringConst"); | |
93 | DefineOptionalParameter(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst"); | |
94 | DefineOptionalParameter(SurfaceTension, "surfaceTension"); | |
95 | DefineOptionalParameter(PrintPressureTensor, "printPressureTensor"); | |
96 | < | DefineOptionalParameter(ElectrostaticSummationMethod, "electrostaticSummationMethod"); |
97 | < | DefineOptionalParameter(ElectrostaticScreeningMethod, "electrostaticScreeningMethod"); |
96 | > | DefineOptionalParameter(TaggedAtomPair, "taggedAtomPair"); |
97 | > | DefineOptionalParameter(PrintTaggedPairDistance, "printTaggedPairDistance"); |
98 | DefineOptionalParameter(CutoffPolicy, "cutoffPolicy"); | |
99 | DefineOptionalParameter(SwitchingFunctionType, "switchingFunctionType"); | |
100 | < | DefineOptionalParameterWithDefaultValue(MixingRule, "mixingRule", "standard"); |
100 | > | DefineOptionalParameter(HydroPropFile, "HydroPropFile"); |
101 | > | DefineOptionalParameter(Viscosity, "viscosity"); |
102 | > | DefineOptionalParameter(BeadSize, "beadSize"); |
103 | > | DefineOptionalParameter(FrozenBufferRadius, "frozenBufferRadius"); |
104 | > | DefineOptionalParameter(LangevinBufferRadius, "langevinBufferRadius"); |
105 | > | DefineOptionalParameter(NeighborListNeighbors,"NeighborListNeighbors"); |
106 | > | DefineOptionalParameter(UseMultipleTemperatureMethod, "useMultipleTemperatureMethod"); |
107 | > | DefineOptionalParameter(MTM_Ce, "MTM_Ce"); |
108 | > | DefineOptionalParameter(MTM_G, "MTM_G"); |
109 | > | DefineOptionalParameter(MTM_Io, "MTM_Io"); |
110 | > | DefineOptionalParameter(MTM_Sigma, "MTM_Sigma"); |
111 | > | DefineOptionalParameter(MTM_R, "MTM_R"); |
112 | > | |
113 | > | |
114 | > | |
115 | DefineOptionalParameterWithDefaultValue(UsePeriodicBoundaryConditions, "usePeriodicBoundaryConditions", true); | |
116 | + | DefineOptionalParameterWithDefaultValue(UseAtomicVirial, "useAtomicVirial", true); |
117 | DefineOptionalParameterWithDefaultValue(UseInitalTime, "useInitialTime", false); | |
118 | DefineOptionalParameterWithDefaultValue(UseIntialExtendedSystemState, "useInitialExtendedSystemState", false); | |
119 | DefineOptionalParameterWithDefaultValue(OrthoBoxTolerance, "orthoBoxTolerance", 1E-6); | |
# | Line 134 | Line 122 | Globals::Globals(){ | |
122 | DefineOptionalParameterWithDefaultValue(ThermIntDistSpringConst, "thermIntDistSpringConst", 6.0); | |
123 | DefineOptionalParameterWithDefaultValue(ThermIntThetaSpringConst, "thermIntThetaSpringConst", 7.5); | |
124 | DefineOptionalParameterWithDefaultValue(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst", 13.5); | |
125 | < | DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 0.2); |
125 | > | DefineOptionalParameterWithDefaultValue(ElectrostaticSummationMethod, "electrostaticSummationMethod", "SHIFTED_FORCE"); |
126 | > | DefineOptionalParameterWithDefaultValue(ElectrostaticScreeningMethod, "electrostaticScreeningMethod", "DAMPED"); |
127 | > | DefineOptionalParameterWithDefaultValue(Dielectric, "dielectric", 78.5); |
128 | DefineOptionalParameterWithDefaultValue(CompressDumpFile, "compressDumpFile", 0); | |
129 | DefineOptionalParameterWithDefaultValue(OutputForceVector, "outputForceVector", 0); | |
130 | DefineOptionalParameterWithDefaultValue(SkinThickness, "skinThickness", 1.0); | |
131 | DefineOptionalParameterWithDefaultValue(StatFileFormat, "statFileFormat", "TIME|TOTAL_ENERGY|POTENTIAL_ENERGY|KINETIC_ENERGY|TEMPERATURE|PRESSURE|VOLUME|CONSERVED_QUANTITY"); | |
132 | + | DefineOptionalParameterWithDefaultValue(UseSphericalBoundaryConditions, "useSphericalBoundaryConditions", false); |
133 | + | DefineOptionalParameterWithDefaultValue(AccumulateBoxDipole, "accumulateBoxDipole", false); |
134 | ||
135 | < | |
136 | < | } |
137 | < | |
138 | < | int Globals::globalAssign( event* the_event ){ |
139 | < | char errorMessage[65535]; |
148 | < | int key; |
149 | < | interface_assign_type the_type = the_event->evt.asmt.asmt_type; |
150 | < | char* lhs = the_event->evt.asmt.lhs; |
151 | < | std::string keyword(lhs); |
152 | < | |
153 | < | bool result = false; |
154 | < | |
155 | < | /**@todo fix memory leak */ |
156 | < | ParamMap::iterator i =parameters_.find(keyword); |
157 | < | if (i != parameters_.end()) { |
158 | < | if( the_type == STRING ){ |
159 | < | result = i->second->setData(std::string(the_event->evt.asmt.rhs.sval)); |
160 | < | if (!result ) { |
161 | < | sprintf(errorMessage, "Error in parsing %s: expect %s, but get a string \"%s\".\n", keyword.c_str(), i->second->getParamType().c_str(), the_event->evt.asmt.rhs.sval); |
162 | < | the_event->err_msg = strdup(errorMessage); |
163 | < | } |
164 | < | } else if( the_type == DOUBLE ){ |
165 | < | result = i->second->setData(the_event->evt.asmt.rhs.dval); |
166 | < | if (!result ) |
167 | < | sprintf(errorMessage, "Error in parsing %s: expect %s, but get a double %f.\n", keyword.c_str(), i->second->getParamType().c_str(), the_event->evt.asmt.rhs.dval ); |
168 | < | the_event->err_msg = strdup(errorMessage); |
169 | < | } |
170 | < | else if (the_type == INT ){ |
171 | < | result = i->second->setData(the_event->evt.asmt.rhs.ival); |
172 | < | if (!result ) |
173 | < | sprintf(errorMessage, "Error in parsing %s: expect %s, but get an int %d.\n", keyword.c_str(), i->second->getParamType().c_str(), the_event->evt.asmt.rhs.ival ); |
174 | < | the_event->err_msg = strdup(errorMessage); |
175 | < | |
176 | < | } else { |
177 | < | sprintf(errorMessage, "Internal error of parser\n"); |
178 | < | the_event->err_msg = strdup(errorMessage); |
179 | < | } |
180 | < | } else { |
181 | < | sprintf(errorMessage, "%s is an unrecognized keyword\n", keyword.c_str() ); |
182 | < | the_event->err_msg = strdup(errorMessage); |
183 | < | } |
184 | < | |
185 | < | if (keyword == "nComponents" && getNComponents() > 0) { |
186 | < | components = new Component*[getNComponents()]; |
187 | < | }else if (keyword == "nZconstraints" && getNZconstraints() > 0) { |
188 | < | zConstraints = new ZconStamp*[getNZconstraints()]; |
189 | < | } |
190 | < | |
191 | < | return result; |
192 | < | } |
193 | < | |
194 | < | int Globals::newComponent( event* the_event ){ |
195 | < | |
196 | < | current_component = new Component; |
197 | < | int index = the_event->evt.blk_index; |
198 | < | char err[200]; |
199 | < | |
200 | < | if( haveNComponents() && index < getNComponents() ) |
201 | < | components[index] = current_component; |
202 | < | else{ |
203 | < | if( haveNComponents() ){ |
204 | < | sprintf( err, "meta-data parsing error: %d out of nComponents range", |
205 | < | index ); |
206 | < | the_event->err_msg = strdup( err ); |
207 | < | return 0; |
208 | < | } |
209 | < | else{ |
210 | < | the_event->err_msg = strdup("meta-data parsing error: nComponents not given before" |
211 | < | " first component declaration." ); |
212 | < | return 0; |
213 | < | } |
214 | < | } |
215 | < | |
216 | < | return 1; |
217 | < | } |
218 | < | |
219 | < | |
220 | < | |
221 | < | int Globals::componentAssign( event* the_event ){ |
222 | < | |
223 | < | switch( the_event->evt.asmt.asmt_type ){ |
224 | < | |
225 | < | case STRING: |
226 | < | return current_component->assignString( the_event->evt.asmt.lhs, |
227 | < | the_event->evt.asmt.rhs.sval, |
228 | < | &(the_event->err_msg)); |
229 | < | break; |
230 | < | |
231 | < | case DOUBLE: |
232 | < | return current_component->assignDouble( the_event->evt.asmt.lhs, |
233 | < | the_event->evt.asmt.rhs.dval, |
234 | < | &(the_event->err_msg)); |
235 | < | break; |
236 | < | |
237 | < | case INT: |
238 | < | return current_component->assignInt( the_event->evt.asmt.lhs, |
239 | < | the_event->evt.asmt.rhs.ival, |
240 | < | &(the_event->err_msg)); |
241 | < | break; |
242 | < | |
243 | < | default: |
244 | < | the_event->err_msg = strdup( "Globals error. Invalid component" |
245 | < | " assignment type" ); |
246 | < | return 0; |
247 | < | break; |
248 | < | } |
249 | < | return 0; |
250 | < | } |
251 | < | |
252 | < | int Globals::componentEnd( event* the_event ){ |
253 | < | |
254 | < | the_event->err_msg = current_component->checkMe(); |
255 | < | if( the_event->err_msg != NULL ) return 0; |
256 | < | |
257 | < | return 1; |
258 | < | } |
259 | < | |
260 | < | int Globals::newZconstraint( event* the_event ){ |
135 | > | DefineOptionalParameterWithDefaultValue(UseRNEMD, "useRNEMD", false); |
136 | > | DefineOptionalParameterWithDefaultValue(RNEMD_swapTime, "RNEMD_swapTime", 100.0); |
137 | > | DefineOptionalParameterWithDefaultValue(RNEMD_nBins, "RNEMD_nBins", 15); |
138 | > | DefineOptionalParameterWithDefaultValue(RNEMD_swapType, "RNEMD_swapType", "Kinetic"); |
139 | > | DefineOptionalParameterWithDefaultValue(RNEMD_objectSelection, "RNEMD_objectSelection", "select all"); |
140 | ||
141 | ||
142 | < | int index = the_event->evt.blk_index; |
143 | < | char err[200]; |
144 | < | current_zConstraint = new ZconStamp( index ); |
266 | < | |
267 | < | if( haveNZconstraints() && index < getNZconstraints() ) |
268 | < | zConstraints[index] = current_zConstraint; |
269 | < | else{ |
270 | < | if( haveNZconstraints() ){ |
271 | < | sprintf( err, "meta-data parsing error: %d out of nZconstraints range", |
272 | < | index ); |
273 | < | the_event->err_msg = strdup( err ); |
274 | < | return 0; |
275 | < | } |
276 | < | else{ |
277 | < | the_event->err_msg = strdup("meta-data parsing error: nZconstraints" |
278 | < | " not given before" |
279 | < | " first zConstraint declaration." ); |
280 | < | return 0; |
281 | < | } |
282 | < | } |
283 | < | |
284 | < | return 1; |
285 | < | } |
286 | < | |
287 | < | |
288 | < | |
289 | < | int Globals::zConstraintAssign( event* the_event ){ |
290 | < | |
291 | < | switch( the_event->evt.asmt.asmt_type ){ |
142 | > | deprecatedKeywords_.insert("nComponents"); |
143 | > | deprecatedKeywords_.insert("nZconstraints"); |
144 | > | deprecatedKeywords_.insert("initialConfig"); |
145 | ||
293 | – | case STRING: |
294 | – | return current_zConstraint->assignString( the_event->evt.asmt.lhs, |
295 | – | the_event->evt.asmt.rhs.sval, |
296 | – | &(the_event->err_msg)); |
297 | – | break; |
298 | – | |
299 | – | case DOUBLE: |
300 | – | return current_zConstraint->assignDouble( the_event->evt.asmt.lhs, |
301 | – | the_event->evt.asmt.rhs.dval, |
302 | – | &(the_event->err_msg)); |
303 | – | break; |
304 | – | |
305 | – | case INT: |
306 | – | return current_zConstraint->assignInt( the_event->evt.asmt.lhs, |
307 | – | the_event->evt.asmt.rhs.ival, |
308 | – | &(the_event->err_msg)); |
309 | – | break; |
310 | – | |
311 | – | default: |
312 | – | the_event->err_msg = strdup( "Globals error. Invalid zConstraint" |
313 | – | " assignment type" ); |
314 | – | return 0; |
315 | – | break; |
316 | – | } |
317 | – | return 0; |
146 | } | |
147 | ||
148 | < | int Globals::zConstraintEnd( event* the_event ){ |
149 | < | |
150 | < | the_event->err_msg = current_zConstraint->checkMe(); |
323 | < | if( the_event->err_msg != NULL ) return 0; |
324 | < | |
325 | < | return 1; |
148 | > | Globals::~Globals() { |
149 | > | MemoryUtils::deletePointers(components_); |
150 | > | MemoryUtils::deletePointers(zconstraints_); |
151 | } | |
152 | ||
153 | < | char* Globals::checkMe( void ){ |
153 | > | void Globals::validate() { |
154 | > | DataHolder::validate(); |
155 | ||
330 | – | |
331 | – | std::string err("The following required keywords are missing:\n"); |
332 | – | short int have_err = 0; |
333 | – | |
334 | – | ParamMap::iterator i; |
335 | – | for (i = parameters_.begin(); i != parameters_.end(); ++i) { |
336 | – | if (!i->second->isOptional() && i->second->empty()) { |
337 | – | err += i->second->getKeyword() + "\n"; |
338 | – | } |
339 | – | } |
340 | – | |
156 | CheckParameter(ForceField, isNotEmpty()); | |
342 | – | CheckParameter(NComponents,isPositive()); |
157 | CheckParameter(TargetTemp, isPositive()); | |
158 | < | CheckParameter(Ensemble, isEqualIgnoreCase(std::string("NVE")) || |
345 | < | isEqualIgnoreCase(std::string("NVT")) || |
346 | < | isEqualIgnoreCase(std::string("NPTi")) || |
347 | < | isEqualIgnoreCase(std::string("NPTf")) || |
348 | < | isEqualIgnoreCase(std::string("NPTxyz")) ); |
158 | > | CheckParameter(Ensemble, isEqualIgnoreCase("NVE") || isEqualIgnoreCase("NVT") || isEqualIgnoreCase("NPTi") || isEqualIgnoreCase("NPTf") || isEqualIgnoreCase("NPTxyz") || isEqualIgnoreCase("NPAT") || isEqualIgnoreCase("LANGEVINDYNAMICS") || isEqualIgnoreCase("LD") || isEqualIgnoreCase("NPRT") || isEqualIgnoreCase("NPGT") || isEqualIgnoreCase("NGammaT") || isEqualIgnoreCase("NGT") || isEqualIgnoreCase("SMIPD")); |
159 | CheckParameter(Dt, isPositive()); | |
160 | CheckParameter(RunTime, isPositive()); | |
351 | – | CheckParameter(InitialConfig, isNotEmpty()); |
161 | CheckParameter(FinalConfig, isNotEmpty()); | |
353 | – | CheckParameter(NMol, isPositive()); |
354 | – | CheckParameter(Density, isPositive()); |
355 | – | CheckParameter(Box, isPositive()); |
356 | – | CheckParameter(BoxX, isPositive()); |
357 | – | CheckParameter(BoxY, isPositive()); |
358 | – | CheckParameter(BoxZ, isPositive()); |
162 | CheckParameter(SampleTime, isNonNegative()); | |
163 | CheckParameter(ResetTime, isNonNegative()); | |
164 | CheckParameter(StatusTime, isNonNegative()); | |
# | Line 363 | Line 166 | char* Globals::checkMe( void ){ | |
166 | CheckParameter(SwitchingRadius, isNonNegative()); | |
167 | CheckParameter(Dielectric, isPositive()); | |
168 | CheckParameter(ThermalTime, isNonNegative()); | |
366 | – | CheckParameter(TargetPressure, isPositive()); |
169 | CheckParameter(TauThermostat, isPositive()); | |
170 | CheckParameter(TauBarostat, isPositive()); | |
171 | CheckParameter(ZconsTime, isPositive()); | |
370 | – | CheckParameter(NZconstraints, isPositive()); |
172 | CheckParameter(ZconsTol, isPositive()); | |
372 | – | //CheckParameter(ZconsForcePolicy,); |
173 | CheckParameter(Seed, isPositive()); | |
174 | < | CheckParameter(Minimizer, isEqualIgnoreCase(std::string("SD")) || |
375 | < | isEqualIgnoreCase(std::string("CG"))); |
174 | > | CheckParameter(Minimizer, isEqualIgnoreCase("SD") || isEqualIgnoreCase("CG")); |
175 | CheckParameter(MinimizerMaxIter, isPositive()); | |
176 | CheckParameter(MinimizerWriteFrq, isPositive()); | |
177 | CheckParameter(MinimizerStepSize, isPositive()); | |
# | Line 382 | Line 181 | char* Globals::checkMe( void ){ | |
181 | CheckParameter(MinimizerLSMaxIter, isPositive()); | |
182 | CheckParameter(ZconsGap, isPositive()); | |
183 | CheckParameter(ZconsFixtime, isPositive()); | |
184 | < | CheckParameter(ThermodynamicIntegrationLambda, isPositive()); |
184 | > | CheckParameter(ThermodynamicIntegrationLambda, isNonNegative()); |
185 | CheckParameter(ThermodynamicIntegrationK, isPositive()); | |
186 | CheckParameter(ForceFieldVariant, isNotEmpty()); | |
187 | CheckParameter(ForceFieldFileName, isNotEmpty()); | |
188 | CheckParameter(ThermIntDistSpringConst, isPositive()); | |
189 | CheckParameter(ThermIntThetaSpringConst, isPositive()); | |
190 | CheckParameter(ThermIntOmegaSpringConst, isPositive()); | |
191 | < | CheckParameter(SurfaceTension, isPositive()); |
192 | < | CheckParameter(ElectrostaticSummationMethod, |
193 | < | isEqualIgnoreCase(std::string("NONE")) || |
194 | < | isEqualIgnoreCase(std::string("SHIFTED_POTENTIAL")) || |
396 | < | isEqualIgnoreCase(std::string("SHIFTED_FORCE")) || |
397 | < | isEqualIgnoreCase(std::string("REACTION_FIELD"))); |
398 | < | CheckParameter(ElectrostaticScreeningMethod, |
399 | < | isEqualIgnoreCase(std::string("UNDAMPED")) || |
400 | < | isEqualIgnoreCase(std::string("DAMPED"))); |
401 | < | CheckParameter(CutoffPolicy, isEqualIgnoreCase(std::string("MIX")) || |
402 | < | isEqualIgnoreCase(std::string("MAX")) || |
403 | < | isEqualIgnoreCase(std::string("TRADITIONAL"))); |
404 | < | CheckParameter(SwitchingFunctionType, |
405 | < | isEqualIgnoreCase(std::string("CUBIC")) || |
406 | < | isEqualIgnoreCase(std::string("FIFTH_ORDER_POLYNOMIAL"))); |
191 | > | CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase("NONE") || isEqualIgnoreCase("SHIFTED_POTENTIAL") || isEqualIgnoreCase("SHIFTED_FORCE") || isEqualIgnoreCase("REACTION_FIELD")); |
192 | > | CheckParameter(ElectrostaticScreeningMethod, isEqualIgnoreCase("UNDAMPED") || isEqualIgnoreCase("DAMPED")); |
193 | > | CheckParameter(CutoffPolicy, isEqualIgnoreCase("MIX") || isEqualIgnoreCase("MAX") || isEqualIgnoreCase("TRADITIONAL")); |
194 | > | CheckParameter(SwitchingFunctionType, isEqualIgnoreCase("CUBIC") || isEqualIgnoreCase("FIFTH_ORDER_POLYNOMIAL")); |
195 | //CheckParameter(StatFileFormat,); | |
408 | – | //CheckParameter(MixingRule,); |
196 | CheckParameter(OrthoBoxTolerance, isPositive()); | |
197 | CheckParameter(ThermIntDistSpringConst, isPositive()); | |
198 | CheckParameter(ThermIntThetaSpringConst, isPositive()); | |
199 | CheckParameter(ThermIntOmegaSpringConst, isPositive()); | |
200 | CheckParameter(DampingAlpha,isNonNegative()); | |
201 | CheckParameter(SkinThickness, isPositive()); | |
202 | < | |
203 | < | //@todo memory leak |
204 | < | if( have_err ) |
205 | < | return strdup( err.c_str() ); |
206 | < | |
207 | < | return NULL; |
202 | > | CheckParameter(Viscosity, isNonNegative()); |
203 | > | CheckParameter(BeadSize, isPositive()); |
204 | > | CheckParameter(FrozenBufferRadius, isPositive()); |
205 | > | CheckParameter(LangevinBufferRadius, isPositive()); |
206 | > | CheckParameter(NeighborListNeighbors, isPositive()); |
207 | > | CheckParameter(RNEMD_swapTime, isPositive()); |
208 | > | CheckParameter(RNEMD_nBins, isPositive()); |
209 | > | CheckParameter(RNEMD_swapType, isEqualIgnoreCase("Kinetic") || isEqualIgnoreCase("Px") || isEqualIgnoreCase("Py") || isEqualIgnoreCase("Pz")); |
210 | ||
211 | + | for(std::vector<Component*>::iterator i = components_.begin(); i != components_.end(); ++i) { |
212 | + | if (!(*i)->findMoleculeStamp(moleculeStamps_)) { |
213 | + | std::ostringstream oss; |
214 | + | oss << "Globals Error: can not find molecule stamp for component " << (*i)->getType() << std::endl; |
215 | + | throw OOPSEException(oss.str()); |
216 | + | } |
217 | + | } |
218 | + | } |
219 | + | |
220 | + | bool Globals::addComponent(Component* comp) { |
221 | + | components_.push_back(comp); |
222 | + | return true; |
223 | + | } |
224 | ||
225 | + | bool Globals::addZConsStamp(ZConsStamp* zcons) { |
226 | + | zconstraints_.push_back(zcons); |
227 | + | return true; |
228 | } | |
229 | ||
230 | < | int Globals::globalEnd( event* the_event ){ |
231 | < | |
232 | < | the_event->err_msg = checkMe(); |
233 | < | if( the_event->err_msg != NULL ) return 0; |
230 | > | bool Globals::addMoleculeStamp(MoleculeStamp* molStamp) { |
231 | > | std::string molStampName = molStamp->getName(); |
232 | > | std::map<std::string, MoleculeStamp*>::iterator i; |
233 | > | bool ret = false; |
234 | > | i = moleculeStamps_.find(molStampName); |
235 | > | if (i == moleculeStamps_.end()) { |
236 | > | moleculeStamps_.insert(std::map<std::string, MoleculeStamp*>::value_type(molStampName, molStamp)); |
237 | > | ret = true; |
238 | > | } else { |
239 | > | std::ostringstream oss; |
240 | > | oss << "Globals Error: Molecule Stamp " << molStamp->getName() << "appears multiple times\n"; |
241 | > | throw OOPSEException(oss.str()); |
242 | > | } |
243 | > | return ret; |
244 | > | } |
245 | > | |
246 | ||
430 | – | return 1; |
247 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |