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())) 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"); |
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"); |
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"); |
95 |
|
DefineOptionalParameter(SurfaceTension, "surfaceTension"); |
96 |
|
DefineOptionalParameter(PrintPressureTensor, "printPressureTensor"); |
97 |
|
DefineOptionalParameter(ElectrostaticSummationMethod, "electrostaticSummationMethod"); |
98 |
+ |
DefineOptionalParameter(ElectrostaticScreeningMethod, "electrostaticScreeningMethod"); |
99 |
|
DefineOptionalParameter(CutoffPolicy, "cutoffPolicy"); |
100 |
< |
DefineOptionalParameter(StatFileFormat, "statFileFormat"); |
127 |
< |
|
100 |
> |
DefineOptionalParameter(SwitchingFunctionType, "switchingFunctionType"); |
101 |
|
DefineOptionalParameterWithDefaultValue(MixingRule, "mixingRule", "standard"); |
102 |
|
DefineOptionalParameterWithDefaultValue(UsePeriodicBoundaryConditions, "usePeriodicBoundaryConditions", true); |
103 |
|
DefineOptionalParameterWithDefaultValue(UseInitalTime, "useInitialTime", false); |
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 |
< |
|
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 |
< |
} |
115 |
> |
DefineOptionalParameterWithDefaultValue(StatFileFormat, "statFileFormat", "TIME|TOTAL_ENERGY|POTENTIAL_ENERGY|KINETIC_ENERGY|TEMPERATURE|PRESSURE|VOLUME|CONSERVED_QUANTITY"); |
116 |
|
|
252 |
– |
int Globals::newZconstraint( event* the_event ){ |
253 |
– |
|
117 |
|
|
118 |
< |
int index = the_event->evt.blk_index; |
119 |
< |
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 |
< |
} |
275 |
< |
|
276 |
< |
return 1; |
277 |
< |
} |
278 |
< |
|
279 |
< |
|
280 |
< |
|
281 |
< |
int Globals::zConstraintAssign( event* the_event ){ |
282 |
< |
|
283 |
< |
switch( the_event->evt.asmt.asmt_type ){ |
118 |
> |
deprecatedKeywords_.insert("nComponents"); |
119 |
> |
deprecatedKeywords_.insert("nZconstraints"); |
120 |
|
|
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; |
121 |
|
} |
122 |
|
|
123 |
< |
int Globals::zConstraintEnd( event* the_event ){ |
123 |
> |
Globals::~Globals() { |
124 |
|
|
314 |
– |
the_event->err_msg = current_zConstraint->checkMe(); |
315 |
– |
if( the_event->err_msg != NULL ) return 0; |
125 |
|
|
317 |
– |
return 1; |
126 |
|
} |
127 |
|
|
128 |
< |
char* Globals::checkMe( void ){ |
128 |
> |
void Globals::validate() { |
129 |
> |
DataHolder::validate(); |
130 |
|
|
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 |
– |
|
131 |
|
CheckParameter(ForceField, isNotEmpty()); |
334 |
– |
CheckParameter(NComponents,isPositive()); |
132 |
|
CheckParameter(TargetTemp, isPositive()); |
133 |
< |
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 |
< |
|
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()); |
344 |
– |
CheckParameter(NMol, isPositive()); |
345 |
– |
CheckParameter(Density, isPositive()); |
346 |
– |
CheckParameter(Box, isPositive()); |
347 |
– |
CheckParameter(BoxX, isPositive()); |
348 |
– |
CheckParameter(BoxY, isPositive()); |
349 |
– |
CheckParameter(BoxZ, isPositive()); |
138 |
|
CheckParameter(SampleTime, isNonNegative()); |
139 |
|
CheckParameter(ResetTime, isNonNegative()); |
140 |
|
CheckParameter(StatusTime, isNonNegative()); |
146 |
|
CheckParameter(TauThermostat, isPositive()); |
147 |
|
CheckParameter(TauBarostat, isPositive()); |
148 |
|
CheckParameter(ZconsTime, isPositive()); |
361 |
– |
CheckParameter(NZconstraints, isPositive()); |
149 |
|
CheckParameter(ZconsTol, isPositive()); |
363 |
– |
//CheckParameter(ZconsForcePolicy,); |
150 |
|
CheckParameter(Seed, isPositive()); |
151 |
|
CheckParameter(Minimizer, isEqualIgnoreCase(std::string("SD")) || isEqualIgnoreCase(std::string("CG"))); |
152 |
|
CheckParameter(MinimizerMaxIter, isPositive()); |
166 |
|
CheckParameter(ThermIntThetaSpringConst, isPositive()); |
167 |
|
CheckParameter(ThermIntOmegaSpringConst, isPositive()); |
168 |
|
CheckParameter(SurfaceTension, isPositive()); |
169 |
< |
CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase(std::string("NONE")) || isEqualIgnoreCase(std::string("UNDAMPED_WOLF")) || isEqualIgnoreCase(std::string("DAMPED_WOLF")) || isEqualIgnoreCase(std::string("REACTION_FIELD")) ); |
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()); |
393 |
– |
|
394 |
– |
//@todo memory leak |
395 |
– |
if( have_err ) |
396 |
– |
return strdup( err.c_str() ); |
397 |
– |
|
398 |
– |
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 |
+ |
} |