# | Line 46 | Line 46 | |
---|---|---|
46 | ||
47 | #include "io/Globals.hpp" | |
48 | #include "utils/simError.h" | |
49 | – | #ifdef IS_MPI |
50 | – | #include "io/mpiBASS.h" |
51 | – | #endif // is_mpi |
49 | ||
50 | #include "io/ParamConstraint.hpp" | |
51 | ||
52 | < | #define DefineParameter(NAME,KEYWORD) \ |
53 | < | 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"); | |
# | Line 78 | Line 59 | Globals::Globals(){ | |
59 | DefineOptionalParameter(RunTime, "runTime"); | |
60 | DefineOptionalParameter(InitialConfig, "initialConfig"); | |
61 | 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"); |
62 | DefineOptionalParameter(SampleTime, "sampleTime"); | |
63 | DefineOptionalParameter(ResetTime, "resetTime"); | |
64 | DefineOptionalParameter(StatusTime, "statusTime"); | |
# | Line 96 | Line 71 | Globals::Globals(){ | |
71 | DefineOptionalParameter(TauThermostat, "tauThermostat"); | |
72 | DefineOptionalParameter(TauBarostat, "tauBarostat"); | |
73 | DefineOptionalParameter(ZconsTime, "zconsTime"); | |
99 | – | DefineOptionalParameter(NZconstraints, "nZconstraints"); |
74 | DefineOptionalParameter(ZconsTol, "zconsTol"); | |
75 | DefineOptionalParameter(ZconsForcePolicy, "zconsForcePolicy"); | |
76 | DefineOptionalParameter(Seed, "seed"); | |
# | Line 121 | Line 95 | Globals::Globals(){ | |
95 | DefineOptionalParameter(SurfaceTension, "surfaceTension"); | |
96 | DefineOptionalParameter(PrintPressureTensor, "printPressureTensor"); | |
97 | DefineOptionalParameter(ElectrostaticSummationMethod, "electrostaticSummationMethod"); | |
98 | < | DefineOptionalParameter(ScreeningMethod, "screeningMethod"); |
98 | > | DefineOptionalParameter(ElectrostaticScreeningMethod, "electrostaticScreeningMethod"); |
99 | DefineOptionalParameter(CutoffPolicy, "cutoffPolicy"); | |
100 | < | |
100 | > | DefineOptionalParameter(SwitchingFunctionType, "switchingFunctionType"); |
101 | DefineOptionalParameterWithDefaultValue(MixingRule, "mixingRule", "standard"); | |
102 | DefineOptionalParameterWithDefaultValue(UsePeriodicBoundaryConditions, "usePeriodicBoundaryConditions", true); | |
103 | DefineOptionalParameterWithDefaultValue(UseInitalTime, "useInitialTime", false); | |
# | Line 134 | Line 108 | Globals::Globals(){ | |
108 | DefineOptionalParameterWithDefaultValue(ThermIntDistSpringConst, "thermIntDistSpringConst", 6.0); | |
109 | DefineOptionalParameterWithDefaultValue(ThermIntThetaSpringConst, "thermIntThetaSpringConst", 7.5); | |
110 | DefineOptionalParameterWithDefaultValue(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst", 13.5); | |
111 | < | DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 1.5); |
111 | > | DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 0.2); |
112 | DefineOptionalParameterWithDefaultValue(CompressDumpFile, "compressDumpFile", 0); | |
113 | + | DefineOptionalParameterWithDefaultValue(OutputForceVector, "outputForceVector", 0); |
114 | DefineOptionalParameterWithDefaultValue(SkinThickness, "skinThickness", 1.0); | |
115 | DefineOptionalParameterWithDefaultValue(StatFileFormat, "statFileFormat", "TIME|TOTAL_ENERGY|POTENTIAL_ENERGY|KINETIC_ENERGY|TEMPERATURE|PRESSURE|VOLUME|CONSERVED_QUANTITY"); | |
141 | – | |
142 | – | |
143 | – | } |
144 | – | |
145 | – | int Globals::globalAssign( event* the_event ){ |
146 | – | char errorMessage[65535]; |
147 | – | int key; |
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 = false; |
153 | – | |
154 | – | /**@todo fix memory leak */ |
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(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); |
161 | – | the_event->err_msg = strdup(errorMessage); |
162 | – | } |
163 | – | } else if( the_type == DOUBLE ){ |
164 | – | result = i->second->setData(the_event->evt.asmt.rhs.dval); |
165 | – | if (!result ) |
166 | – | 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 ); |
167 | – | the_event->err_msg = strdup(errorMessage); |
168 | – | } |
169 | – | else if (the_type == INT ){ |
170 | – | result = i->second->setData(the_event->evt.asmt.rhs.ival); |
171 | – | if (!result ) |
172 | – | 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 ); |
173 | – | the_event->err_msg = strdup(errorMessage); |
174 | – | |
175 | – | } else { |
176 | – | sprintf(errorMessage, "Internal error of parser\n"); |
177 | – | the_event->err_msg = strdup(errorMessage); |
178 | – | } |
179 | – | } else { |
180 | – | sprintf(errorMessage, "%s is an unrecognized keyword\n", keyword.c_str() ); |
181 | – | the_event->err_msg = strdup(errorMessage); |
182 | – | } |
183 | – | |
184 | – | if (keyword == "nComponents" && getNComponents() > 0) { |
185 | – | components = new Component*[getNComponents()]; |
186 | – | }else if (keyword == "nZconstraints" && getNZconstraints() > 0) { |
187 | – | zConstraints = new ZconStamp*[getNZconstraints()]; |
188 | – | } |
189 | – | |
190 | – | return result; |
191 | – | } |
192 | – | |
193 | – | int Globals::newComponent( event* the_event ){ |
194 | – | |
195 | – | current_component = new Component; |
196 | – | int index = the_event->evt.blk_index; |
197 | – | char err[200]; |
198 | – | |
199 | – | if( haveNComponents() && index < getNComponents() ) |
200 | – | components[index] = current_component; |
201 | – | else{ |
202 | – | if( haveNComponents() ){ |
203 | – | sprintf( err, "meta-data parsing error: %d out of nComponents range", |
204 | – | index ); |
205 | – | the_event->err_msg = strdup( err ); |
206 | – | return 0; |
207 | – | } |
208 | – | else{ |
209 | – | the_event->err_msg = strdup("meta-data parsing error: nComponents not given before" |
210 | – | " first component declaration." ); |
211 | – | return 0; |
212 | – | } |
213 | – | } |
214 | – | |
215 | – | return 1; |
216 | – | } |
217 | – | |
218 | – | |
219 | – | |
220 | – | int Globals::componentAssign( event* the_event ){ |
221 | – | |
222 | – | switch( the_event->evt.asmt.asmt_type ){ |
223 | – | |
224 | – | case STRING: |
225 | – | return current_component->assignString( the_event->evt.asmt.lhs, |
226 | – | the_event->evt.asmt.rhs.sval, |
227 | – | &(the_event->err_msg)); |
228 | – | break; |
229 | – | |
230 | – | case DOUBLE: |
231 | – | return current_component->assignDouble( the_event->evt.asmt.lhs, |
232 | – | the_event->evt.asmt.rhs.dval, |
233 | – | &(the_event->err_msg)); |
234 | – | break; |
235 | – | |
236 | – | case INT: |
237 | – | return current_component->assignInt( the_event->evt.asmt.lhs, |
238 | – | the_event->evt.asmt.rhs.ival, |
239 | – | &(the_event->err_msg)); |
240 | – | break; |
241 | – | |
242 | – | default: |
243 | – | the_event->err_msg = strdup( "Globals error. Invalid component" |
244 | – | " assignment type" ); |
245 | – | return 0; |
246 | – | break; |
247 | – | } |
248 | – | return 0; |
249 | – | } |
250 | – | |
251 | – | int Globals::componentEnd( event* the_event ){ |
252 | – | |
253 | – | the_event->err_msg = current_component->checkMe(); |
254 | – | if( the_event->err_msg != NULL ) return 0; |
116 | ||
256 | – | return 1; |
257 | – | } |
117 | ||
118 | < | int Globals::newZconstraint( event* the_event ){ |
119 | < | |
261 | < | |
262 | < | int index = the_event->evt.blk_index; |
263 | < | char err[200]; |
264 | < | current_zConstraint = new ZconStamp( index ); |
265 | < | |
266 | < | if( haveNZconstraints() && index < getNZconstraints() ) |
267 | < | zConstraints[index] = current_zConstraint; |
268 | < | else{ |
269 | < | if( haveNZconstraints() ){ |
270 | < | sprintf( err, "meta-data parsing error: %d out of nZconstraints range", |
271 | < | index ); |
272 | < | the_event->err_msg = strdup( err ); |
273 | < | return 0; |
274 | < | } |
275 | < | else{ |
276 | < | the_event->err_msg = strdup("meta-data parsing error: nZconstraints" |
277 | < | " not given before" |
278 | < | " first zConstraint declaration." ); |
279 | < | return 0; |
280 | < | } |
281 | < | } |
282 | < | |
283 | < | return 1; |
284 | < | } |
285 | < | |
286 | < | |
287 | < | |
288 | < | int Globals::zConstraintAssign( event* the_event ){ |
289 | < | |
290 | < | switch( the_event->evt.asmt.asmt_type ){ |
118 | > | deprecatedKeywords_.insert("nComponents"); |
119 | > | deprecatedKeywords_.insert("nZconstraints"); |
120 | ||
292 | – | case STRING: |
293 | – | return current_zConstraint->assignString( the_event->evt.asmt.lhs, |
294 | – | the_event->evt.asmt.rhs.sval, |
295 | – | &(the_event->err_msg)); |
296 | – | break; |
297 | – | |
298 | – | case DOUBLE: |
299 | – | return current_zConstraint->assignDouble( the_event->evt.asmt.lhs, |
300 | – | the_event->evt.asmt.rhs.dval, |
301 | – | &(the_event->err_msg)); |
302 | – | break; |
303 | – | |
304 | – | case INT: |
305 | – | return current_zConstraint->assignInt( the_event->evt.asmt.lhs, |
306 | – | the_event->evt.asmt.rhs.ival, |
307 | – | &(the_event->err_msg)); |
308 | – | break; |
309 | – | |
310 | – | default: |
311 | – | the_event->err_msg = strdup( "Globals error. Invalid zConstraint" |
312 | – | " assignment type" ); |
313 | – | return 0; |
314 | – | break; |
315 | – | } |
316 | – | return 0; |
121 | } | |
122 | ||
123 | < | int Globals::zConstraintEnd( event* the_event ){ |
123 | > | Globals::~Globals() { |
124 | ||
321 | – | the_event->err_msg = current_zConstraint->checkMe(); |
322 | – | if( the_event->err_msg != NULL ) return 0; |
125 | ||
324 | – | return 1; |
126 | } | |
127 | ||
128 | < | char* Globals::checkMe( void ){ |
128 | > | void Globals::validate() { |
129 | > | DataHolder::validate(); |
130 | ||
329 | – | |
330 | – | std::string err("The following required keywords are missing:\n"); |
331 | – | short int have_err = 0; |
332 | – | |
333 | – | ParamMap::iterator i; |
334 | – | for (i = parameters_.begin(); i != parameters_.end(); ++i) { |
335 | – | if (!i->second->isOptional() && i->second->empty()) { |
336 | – | err += i->second->getKeyword() + "\n"; |
337 | – | } |
338 | – | } |
339 | – | |
131 | CheckParameter(ForceField, isNotEmpty()); | |
341 | – | CheckParameter(NComponents,isPositive()); |
132 | CheckParameter(TargetTemp, isPositive()); | |
133 | < | CheckParameter(Ensemble, isEqualIgnoreCase(std::string("NVE")) || isEqualIgnoreCase(std::string("NVT")) || |
344 | < | isEqualIgnoreCase(std::string("NPTi")) || isEqualIgnoreCase(std::string("NPTf"))|| |
345 | < | isEqualIgnoreCase(std::string("NPTxyz")) ); |
133 | > | CheckParameter(Ensemble, isEqualIgnoreCase(std::string("NVE")) || isEqualIgnoreCase(std::string("NVT")) || isEqualIgnoreCase(std::string("NPTi")) || isEqualIgnoreCase(std::string("NPTf")) || isEqualIgnoreCase(std::string("NPTxyz")) ); |
134 | CheckParameter(Dt, isPositive()); | |
135 | CheckParameter(RunTime, isPositive()); | |
136 | CheckParameter(InitialConfig, isNotEmpty()); | |
137 | CheckParameter(FinalConfig, isNotEmpty()); | |
350 | – | CheckParameter(NMol, isPositive()); |
351 | – | CheckParameter(Density, isPositive()); |
352 | – | CheckParameter(Box, isPositive()); |
353 | – | CheckParameter(BoxX, isPositive()); |
354 | – | CheckParameter(BoxY, isPositive()); |
355 | – | CheckParameter(BoxZ, isPositive()); |
138 | CheckParameter(SampleTime, isNonNegative()); | |
139 | CheckParameter(ResetTime, isNonNegative()); | |
140 | CheckParameter(StatusTime, isNonNegative()); | |
# | Line 364 | Line 146 | char* Globals::checkMe( void ){ | |
146 | CheckParameter(TauThermostat, isPositive()); | |
147 | CheckParameter(TauBarostat, isPositive()); | |
148 | CheckParameter(ZconsTime, isPositive()); | |
367 | – | CheckParameter(NZconstraints, isPositive()); |
149 | CheckParameter(ZconsTol, isPositive()); | |
369 | – | //CheckParameter(ZconsForcePolicy,); |
150 | CheckParameter(Seed, isPositive()); | |
151 | CheckParameter(Minimizer, isEqualIgnoreCase(std::string("SD")) || isEqualIgnoreCase(std::string("CG"))); | |
152 | CheckParameter(MinimizerMaxIter, isPositive()); | |
# | Line 386 | Line 166 | char* Globals::checkMe( void ){ | |
166 | CheckParameter(ThermIntThetaSpringConst, isPositive()); | |
167 | CheckParameter(ThermIntOmegaSpringConst, isPositive()); | |
168 | CheckParameter(SurfaceTension, isPositive()); | |
169 | < | CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase(std::string("NONE")) || isEqualIgnoreCase(std::string("SHIFTED_POTENTIAL")) || isEqualIgnoreCase(std::string("SHIFTED_FORCE")) || isEqualIgnoreCase(std::string("REACTION_FIELD"))); |
170 | < | CheckParameter(ScreeningMethod, isEqualIgnoreCase(std::string("UNDAMPED")) || isEqualIgnoreCase(std::string("DAMPED"))); |
169 | > | CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase(std::string("NONE")) || isEqualIgnoreCase(std::string("SHIFTED_POTENTIAL")) || isEqualIgnoreCase(std::string("SHIFTED_FORCE")) || isEqualIgnoreCase(std::string("REACTION_FIELD"))); |
170 | > | CheckParameter(ElectrostaticScreeningMethod, isEqualIgnoreCase(std::string("UNDAMPED")) || isEqualIgnoreCase(std::string("DAMPED"))); |
171 | CheckParameter(CutoffPolicy, isEqualIgnoreCase(std::string("MIX")) || isEqualIgnoreCase(std::string("MAX")) || isEqualIgnoreCase(std::string("TRADITIONAL"))); | |
172 | + | CheckParameter(SwitchingFunctionType, isEqualIgnoreCase(std::string("CUBIC")) || isEqualIgnoreCase(std::string("FIFTH_ORDER_POLYNOMIAL"))); |
173 | //CheckParameter(StatFileFormat,); | |
174 | //CheckParameter(MixingRule,); | |
175 | CheckParameter(OrthoBoxTolerance, isPositive()); | |
176 | CheckParameter(ThermIntDistSpringConst, isPositive()); | |
177 | CheckParameter(ThermIntThetaSpringConst, isPositive()); | |
178 | CheckParameter(ThermIntOmegaSpringConst, isPositive()); | |
179 | < | CheckParameter(DampingAlpha,isPositive()); |
179 | > | CheckParameter(DampingAlpha,isNonNegative()); |
180 | CheckParameter(SkinThickness, isPositive()); | |
400 | – | |
401 | – | //@todo memory leak |
402 | – | if( have_err ) |
403 | – | return strdup( err.c_str() ); |
404 | – | |
405 | – | return NULL; |
181 | ||
182 | + | for(std::vector<Component*>::iterator i = components_.begin(); i != components_.end(); ++i) { |
183 | + | if (!(*i)->findMoleculeStamp(moleculeStamps_)) { |
184 | + | std::cout << "Globals Error: can not find molecule stamp for component" << std::endl; |
185 | + | } |
186 | + | } |
187 | + | } |
188 | + | |
189 | + | bool Globals::addComponent(Component* comp) { |
190 | + | components_.push_back(comp); |
191 | + | return true; |
192 | + | } |
193 | ||
194 | + | bool Globals::addZConsStamp(ZConsStamp* zcons) { |
195 | + | zconstraints_.push_back(zcons); |
196 | + | return true; |
197 | } | |
198 | ||
199 | < | int Globals::globalEnd( event* the_event ){ |
200 | < | |
201 | < | the_event->err_msg = checkMe(); |
202 | < | if( the_event->err_msg != NULL ) return 0; |
199 | > | bool Globals::addMoleculeStamp(MoleculeStamp* molStamp) { |
200 | > | std::string molStampName = molStamp->getName(); |
201 | > | std::map<std::string, MoleculeStamp*>::iterator i; |
202 | > | bool ret = false; |
203 | > | i = moleculeStamps_.find(molStampName); |
204 | > | if (i == moleculeStamps_.end()) { |
205 | > | moleculeStamps_.insert(std::map<std::string, MoleculeStamp*>::value_type(molStampName, molStamp)); |
206 | > | ret = true; |
207 | > | } else { |
208 | ||
209 | < | return 1; |
209 | > | } |
210 | > | return ret; |
211 | } | |
212 | + | |
213 | + | |
214 | + | } |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |