# | 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())) std::cout <<"Error in parsing " << NAME.getKeyword() << " : "<< (CONSTRAINT).getConstraintDescription() << std::endl; } |
69 | < | |
70 | < | |
71 | < | Globals::Globals(){ |
72 | < | |
52 | > | namespace oopse { |
53 | > | Globals::Globals() { |
54 | DefineParameter(ForceField, "forceField") | |
74 | – | DefineParameter(NComponents, "nComponents") |
55 | ||
56 | DefineOptionalParameter(TargetTemp, "targetTemp"); | |
57 | DefineOptionalParameter(Ensemble, "ensemble"); | |
# | Line 79 | Line 59 | Globals::Globals(){ | |
59 | DefineOptionalParameter(RunTime, "runTime"); | |
60 | DefineOptionalParameter(InitialConfig, "initialConfig"); | |
61 | DefineOptionalParameter(FinalConfig, "finalConfig"); | |
82 | – | DefineOptionalParameter(NMol, "nMol"); |
83 | – | DefineOptionalParameter(Density, "density"); |
84 | – | DefineOptionalParameter(Box, "box"); |
85 | – | DefineOptionalParameter(BoxX, "boxX"); |
86 | – | DefineOptionalParameter(BoxY, "boxY"); |
87 | – | DefineOptionalParameter(BoxZ, "boxZ"); |
62 | DefineOptionalParameter(SampleTime, "sampleTime"); | |
63 | DefineOptionalParameter(ResetTime, "resetTime"); | |
64 | DefineOptionalParameter(StatusTime, "statusTime"); | |
# | Line 97 | Line 71 | Globals::Globals(){ | |
71 | DefineOptionalParameter(TauThermostat, "tauThermostat"); | |
72 | DefineOptionalParameter(TauBarostat, "tauBarostat"); | |
73 | DefineOptionalParameter(ZconsTime, "zconsTime"); | |
100 | – | DefineOptionalParameter(NZconstraints, "nZconstraints"); |
74 | DefineOptionalParameter(ZconsTol, "zconsTol"); | |
75 | DefineOptionalParameter(ZconsForcePolicy, "zconsForcePolicy"); | |
76 | DefineOptionalParameter(Seed, "seed"); | |
# | Line 122 | Line 95 | Globals::Globals(){ | |
95 | DefineOptionalParameter(SurfaceTension, "surfaceTension"); | |
96 | DefineOptionalParameter(PrintPressureTensor, "printPressureTensor"); | |
97 | DefineOptionalParameter(ElectrostaticSummationMethod, "electrostaticSummationMethod"); | |
98 | + | DefineOptionalParameter(ElectrostaticScreeningMethod, "electrostaticScreeningMethod"); |
99 | DefineOptionalParameter(CutoffPolicy, "cutoffPolicy"); | |
100 | < | DefineOptionalParameter(StatFileFormat, "statFileFormat"); |
100 | > | DefineOptionalParameter(SwitchingFunctionType, "switchingFunctionType"); |
101 | > | DefineOptionalParameter(HydroPropFile, "HydroPropFile"); |
102 | > | DefineOptionalParameter(Viscosity, "viscosity"); |
103 | > | DefineOptionalParameter(BeadSize, "beadSize"); |
104 | ||
128 | – | DefineOptionalParameterWithDefaultValue(MixingRule, "mixingRule", "standard"); |
105 | DefineOptionalParameterWithDefaultValue(UsePeriodicBoundaryConditions, "usePeriodicBoundaryConditions", true); | |
106 | DefineOptionalParameterWithDefaultValue(UseInitalTime, "useInitialTime", false); | |
107 | DefineOptionalParameterWithDefaultValue(UseIntialExtendedSystemState, "useInitialExtendedSystemState", false); | |
# | Line 135 | Line 111 | Globals::Globals(){ | |
111 | DefineOptionalParameterWithDefaultValue(ThermIntDistSpringConst, "thermIntDistSpringConst", 6.0); | |
112 | DefineOptionalParameterWithDefaultValue(ThermIntThetaSpringConst, "thermIntThetaSpringConst", 7.5); | |
113 | DefineOptionalParameterWithDefaultValue(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst", 13.5); | |
114 | < | DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 1.5); |
114 | > | DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 0.2); |
115 | DefineOptionalParameterWithDefaultValue(CompressDumpFile, "compressDumpFile", 0); | |
116 | + | DefineOptionalParameterWithDefaultValue(OutputForceVector, "outputForceVector", 0); |
117 | DefineOptionalParameterWithDefaultValue(SkinThickness, "skinThickness", 1.0); | |
118 | < | |
142 | < | } |
143 | < | |
144 | < | int Globals::globalAssign( event* the_event ){ |
145 | < | |
146 | < | int key; |
147 | < | int token; |
148 | < | interface_assign_type the_type = the_event->evt.asmt.asmt_type; |
149 | < | char* lhs = the_event->evt.asmt.lhs; |
150 | < | std::string keyword(lhs); |
151 | < | |
152 | < | bool result; |
153 | < | |
154 | < | |
155 | < | ParamMap::iterator i =parameters_.find(keyword); |
156 | < | if (i != parameters_.end()) { |
157 | < | if( the_type == STRING ){ |
158 | < | result = i->second->setData(std::string(the_event->evt.asmt.rhs.sval)); |
159 | < | if (!result ) { |
160 | < | sprintf(the_event->err_msg, "Error in parsing meta-data file!\n\t%s must be a string.\n", keyword.c_str() ); |
161 | < | } |
162 | < | } else if( the_type == DOUBLE ){ |
163 | < | result = i->second->setData(the_event->evt.asmt.rhs.dval); |
164 | < | if (!result ) |
165 | < | sprintf(the_event->err_msg, "Error in parsing meta-data file!\n\t%s must be a double.\n", keyword.c_str() ); |
166 | < | } |
167 | < | else if (the_type == INT ){ |
168 | < | result = i->second->setData(the_event->evt.asmt.rhs.ival); |
169 | < | if (!result ) |
170 | < | sprintf(the_event->err_msg, "Error in parsing meta-data file!\n\t%s must be an int.\n", keyword.c_str() ); |
171 | < | |
172 | < | } else { |
173 | < | |
174 | < | } |
175 | < | } |
176 | < | |
177 | < | if (keyword == "nComponents" && getNComponents() > 0) { |
178 | < | components = new Component*[getNComponents()]; |
179 | < | }else if (keyword == "nZconstraints" && getNZconstraints() > 0) { |
180 | < | zConstraints = new ZconStamp*[getNZconstraints()]; |
181 | < | } |
182 | < | |
183 | < | return result; |
184 | < | } |
185 | < | |
186 | < | int Globals::newComponent( event* the_event ){ |
187 | < | |
188 | < | current_component = new Component; |
189 | < | int index = the_event->evt.blk_index; |
190 | < | char err[200]; |
191 | < | |
192 | < | if( haveNComponents() && index < getNComponents() ) |
193 | < | components[index] = current_component; |
194 | < | else{ |
195 | < | if( haveNComponents() ){ |
196 | < | sprintf( err, "meta-data parsing error: %d out of nComponents range", |
197 | < | index ); |
198 | < | the_event->err_msg = strdup( err ); |
199 | < | return 0; |
200 | < | } |
201 | < | else{ |
202 | < | the_event->err_msg = strdup("meta-data parsing error: nComponents not given before" |
203 | < | " first component declaration." ); |
204 | < | return 0; |
205 | < | } |
206 | < | } |
207 | < | |
208 | < | return 1; |
209 | < | } |
210 | < | |
211 | < | |
212 | < | |
213 | < | int Globals::componentAssign( event* the_event ){ |
214 | < | |
215 | < | switch( the_event->evt.asmt.asmt_type ){ |
216 | < | |
217 | < | case STRING: |
218 | < | return current_component->assignString( the_event->evt.asmt.lhs, |
219 | < | the_event->evt.asmt.rhs.sval, |
220 | < | &(the_event->err_msg)); |
221 | < | break; |
222 | < | |
223 | < | case DOUBLE: |
224 | < | return current_component->assignDouble( the_event->evt.asmt.lhs, |
225 | < | the_event->evt.asmt.rhs.dval, |
226 | < | &(the_event->err_msg)); |
227 | < | break; |
228 | < | |
229 | < | case INT: |
230 | < | return current_component->assignInt( the_event->evt.asmt.lhs, |
231 | < | the_event->evt.asmt.rhs.ival, |
232 | < | &(the_event->err_msg)); |
233 | < | break; |
234 | < | |
235 | < | default: |
236 | < | the_event->err_msg = strdup( "Globals error. Invalid component" |
237 | < | " assignment type" ); |
238 | < | return 0; |
239 | < | break; |
240 | < | } |
241 | < | return 0; |
242 | < | } |
243 | < | |
244 | < | int Globals::componentEnd( event* the_event ){ |
245 | < | |
246 | < | the_event->err_msg = current_component->checkMe(); |
247 | < | if( the_event->err_msg != NULL ) return 0; |
248 | < | |
249 | < | return 1; |
250 | < | } |
251 | < | |
252 | < | int Globals::newZconstraint( event* the_event ){ |
253 | < | |
254 | < | |
255 | < | int index = the_event->evt.blk_index; |
256 | < | char err[200]; |
257 | < | current_zConstraint = new ZconStamp( index ); |
258 | < | |
259 | < | if( haveNZconstraints() && index < getNZconstraints() ) |
260 | < | zConstraints[index] = current_zConstraint; |
261 | < | else{ |
262 | < | if( haveNZconstraints() ){ |
263 | < | sprintf( err, "meta-data parsing error: %d out of nZconstraints range", |
264 | < | index ); |
265 | < | the_event->err_msg = strdup( err ); |
266 | < | return 0; |
267 | < | } |
268 | < | else{ |
269 | < | the_event->err_msg = strdup("meta-data parsing error: nZconstraints" |
270 | < | " not given before" |
271 | < | " first zConstraint declaration." ); |
272 | < | return 0; |
273 | < | } |
274 | < | } |
118 | > | DefineOptionalParameterWithDefaultValue(StatFileFormat, "statFileFormat", "TIME|TOTAL_ENERGY|POTENTIAL_ENERGY|KINETIC_ENERGY|TEMPERATURE|PRESSURE|VOLUME|CONSERVED_QUANTITY"); |
119 | ||
276 | – | return 1; |
277 | – | } |
120 | ||
121 | < | |
122 | < | |
281 | < | int Globals::zConstraintAssign( event* the_event ){ |
282 | < | |
283 | < | switch( the_event->evt.asmt.asmt_type ){ |
121 | > | deprecatedKeywords_.insert("nComponents"); |
122 | > | deprecatedKeywords_.insert("nZconstraints"); |
123 | ||
285 | – | case STRING: |
286 | – | return current_zConstraint->assignString( the_event->evt.asmt.lhs, |
287 | – | the_event->evt.asmt.rhs.sval, |
288 | – | &(the_event->err_msg)); |
289 | – | break; |
290 | – | |
291 | – | case DOUBLE: |
292 | – | return current_zConstraint->assignDouble( the_event->evt.asmt.lhs, |
293 | – | the_event->evt.asmt.rhs.dval, |
294 | – | &(the_event->err_msg)); |
295 | – | break; |
296 | – | |
297 | – | case INT: |
298 | – | return current_zConstraint->assignInt( the_event->evt.asmt.lhs, |
299 | – | the_event->evt.asmt.rhs.ival, |
300 | – | &(the_event->err_msg)); |
301 | – | break; |
302 | – | |
303 | – | default: |
304 | – | the_event->err_msg = strdup( "Globals error. Invalid zConstraint" |
305 | – | " assignment type" ); |
306 | – | return 0; |
307 | – | break; |
308 | – | } |
309 | – | return 0; |
124 | } | |
125 | ||
126 | < | int Globals::zConstraintEnd( event* the_event ){ |
127 | < | |
128 | < | the_event->err_msg = current_zConstraint->checkMe(); |
315 | < | if( the_event->err_msg != NULL ) return 0; |
316 | < | |
317 | < | return 1; |
126 | > | Globals::~Globals() { |
127 | > | MemoryUtils::deletePointers(components_); |
128 | > | MemoryUtils::deletePointers(zconstraints_); |
129 | } | |
130 | ||
131 | < | char* Globals::checkMe( void ){ |
131 | > | void Globals::validate() { |
132 | > | DataHolder::validate(); |
133 | ||
322 | – | |
323 | – | std::string err("The following required keywords are missing:\n"); |
324 | – | short int have_err = 0; |
325 | – | |
326 | – | ParamMap::iterator i; |
327 | – | for (i = parameters_.begin(); i != parameters_.end(); ++i) { |
328 | – | if (!i->second->isOptional() && i->second->empty()) { |
329 | – | err += i->second->getKeyword() + "\n"; |
330 | – | } |
331 | – | } |
332 | – | |
134 | CheckParameter(ForceField, isNotEmpty()); | |
334 | – | CheckParameter(NComponents,isPositive()); |
135 | CheckParameter(TargetTemp, isPositive()); | |
136 | < | CheckParameter(Ensemble, isEqualIgnoreCase(std::string("NVE")) || isEqualIgnoreCase(std::string("NVT")) || |
337 | < | isEqualIgnoreCase(std::string("NPTi")) || isEqualIgnoreCase(std::string("NPTf"))|| |
338 | < | isEqualIgnoreCase(std::string("NPTxyz")) ); |
339 | < | |
136 | > | CheckParameter(Ensemble, isEqualIgnoreCase("NVE") || isEqualIgnoreCase("NVT") || isEqualIgnoreCase("NPTi") || isEqualIgnoreCase("NPTf") || isEqualIgnoreCase("NPTxyz") || isEqualIgnoreCase("NPAT") || isEqualIgnoreCase("LANGEVINDYNAMICS") ); |
137 | CheckParameter(Dt, isPositive()); | |
138 | CheckParameter(RunTime, isPositive()); | |
139 | CheckParameter(InitialConfig, isNotEmpty()); | |
140 | CheckParameter(FinalConfig, isNotEmpty()); | |
344 | – | CheckParameter(NMol, isPositive()); |
345 | – | CheckParameter(Density, isPositive()); |
346 | – | CheckParameter(Box, isPositive()); |
347 | – | CheckParameter(BoxX, isPositive()); |
348 | – | CheckParameter(BoxY, isPositive()); |
349 | – | CheckParameter(BoxZ, isPositive()); |
141 | CheckParameter(SampleTime, isNonNegative()); | |
142 | CheckParameter(ResetTime, isNonNegative()); | |
143 | CheckParameter(StatusTime, isNonNegative()); | |
# | Line 358 | Line 149 | char* Globals::checkMe( void ){ | |
149 | CheckParameter(TauThermostat, isPositive()); | |
150 | CheckParameter(TauBarostat, isPositive()); | |
151 | CheckParameter(ZconsTime, isPositive()); | |
361 | – | CheckParameter(NZconstraints, isPositive()); |
152 | CheckParameter(ZconsTol, isPositive()); | |
363 | – | //CheckParameter(ZconsForcePolicy,); |
153 | CheckParameter(Seed, isPositive()); | |
154 | < | CheckParameter(Minimizer, isEqualIgnoreCase(std::string("SD")) || isEqualIgnoreCase(std::string("CG"))); |
154 | > | CheckParameter(Minimizer, isEqualIgnoreCase("SD") || isEqualIgnoreCase("CG")); |
155 | CheckParameter(MinimizerMaxIter, isPositive()); | |
156 | CheckParameter(MinimizerWriteFrq, isPositive()); | |
157 | CheckParameter(MinimizerStepSize, isPositive()); | |
# | Line 380 | Line 169 | char* Globals::checkMe( void ){ | |
169 | CheckParameter(ThermIntThetaSpringConst, isPositive()); | |
170 | CheckParameter(ThermIntOmegaSpringConst, isPositive()); | |
171 | CheckParameter(SurfaceTension, isPositive()); | |
172 | < | CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase(std::string("NONE")) || isEqualIgnoreCase(std::string("UNDAMPED_WOLF")) || isEqualIgnoreCase(std::string("DAMPED_WOLF")) || isEqualIgnoreCase(std::string("REACTION_FIELD")) ); |
173 | < | CheckParameter(CutoffPolicy, isEqualIgnoreCase(std::string("MIX")) || isEqualIgnoreCase(std::string("MAX")) || isEqualIgnoreCase(std::string("TRADITIONAL"))); |
172 | > | CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase("NONE") || isEqualIgnoreCase("SHIFTED_POTENTIAL") || isEqualIgnoreCase("SHIFTED_FORCE") || isEqualIgnoreCase("REACTION_FIELD")); |
173 | > | CheckParameter(ElectrostaticScreeningMethod, isEqualIgnoreCase("UNDAMPED") || isEqualIgnoreCase("DAMPED")); |
174 | > | CheckParameter(CutoffPolicy, isEqualIgnoreCase("MIX") || isEqualIgnoreCase("MAX") || isEqualIgnoreCase("TRADITIONAL")); |
175 | > | CheckParameter(SwitchingFunctionType, isEqualIgnoreCase("CUBIC") || isEqualIgnoreCase("FIFTH_ORDER_POLYNOMIAL")); |
176 | //CheckParameter(StatFileFormat,); | |
386 | – | //CheckParameter(MixingRule,); |
177 | CheckParameter(OrthoBoxTolerance, isPositive()); | |
178 | CheckParameter(ThermIntDistSpringConst, isPositive()); | |
179 | CheckParameter(ThermIntThetaSpringConst, isPositive()); | |
180 | CheckParameter(ThermIntOmegaSpringConst, isPositive()); | |
181 | < | CheckParameter(DampingAlpha,isPositive()); |
181 | > | CheckParameter(DampingAlpha,isNonNegative()); |
182 | CheckParameter(SkinThickness, isPositive()); | |
183 | < | |
184 | < | //@todo memory leak |
185 | < | if( have_err ) |
186 | < | return strdup( err.c_str() ); |
187 | < | |
188 | < | return NULL; |
183 | > | CheckParameter(Viscosity,isNonNegative()); |
184 | > | CheckParameter(BeadSize,isPositive()); |
185 | > | for(std::vector<Component*>::iterator i = components_.begin(); i != components_.end(); ++i) { |
186 | > | if (!(*i)->findMoleculeStamp(moleculeStamps_)) { |
187 | > | std::ostringstream oss; |
188 | > | oss << "Globals Error: can not find molecule stamp for component " << (*i)->getType() << std::endl; |
189 | > | throw OOPSEException(oss.str()); |
190 | > | } |
191 | > | } |
192 | > | } |
193 | > | |
194 | > | bool Globals::addComponent(Component* comp) { |
195 | > | components_.push_back(comp); |
196 | > | return true; |
197 | > | } |
198 | ||
199 | + | bool Globals::addZConsStamp(ZConsStamp* zcons) { |
200 | + | zconstraints_.push_back(zcons); |
201 | + | return true; |
202 | + | } |
203 | ||
204 | + | bool Globals::addMoleculeStamp(MoleculeStamp* molStamp) { |
205 | + | std::string molStampName = molStamp->getName(); |
206 | + | std::map<std::string, MoleculeStamp*>::iterator i; |
207 | + | bool ret = false; |
208 | + | i = moleculeStamps_.find(molStampName); |
209 | + | if (i == moleculeStamps_.end()) { |
210 | + | moleculeStamps_.insert(std::map<std::string, MoleculeStamp*>::value_type(molStampName, molStamp)); |
211 | + | ret = true; |
212 | + | } else { |
213 | + | std::ostringstream oss; |
214 | + | oss << "Globals Error: Molecule Stamp " << molStamp->getName() << "appears multiple times\n"; |
215 | + | throw OOPSEException(oss.str()); |
216 | + | } |
217 | + | return ret; |
218 | } | |
219 | + | |
220 | ||
403 | – | int Globals::globalEnd( event* the_event ){ |
404 | – | |
405 | – | the_event->err_msg = checkMe(); |
406 | – | if( the_event->err_msg != NULL ) return 0; |
407 | – | |
408 | – | return 1; |
221 | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |