ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/io/Globals.cpp
Revision: 710
Committed: Wed Nov 2 20:36:25 2005 UTC (19 years, 6 months ago) by chrisfen
File size: 16979 byte(s)
Log Message: 
changing how we deal with summation and screening methods

File Contents

# User Rev Content
1 gezelter 404 /*
2 gezelter 246 * 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 gezelter 2 #include <stdlib.h>
43     #include <stdio.h>
44     #include <string.h>
45 tim 665 #include <string>
46 gezelter 2
47 tim 3 #include "io/Globals.hpp"
48     #include "utils/simError.h"
49 gezelter 2 #ifdef IS_MPI
50 tim 3 #include "io/mpiBASS.h"
51 gezelter 2 #endif // is_mpi
52    
53 tim 672 #include "io/ParamConstraint.hpp"
54 gezelter 2
55 tim 665 #define DefineParameter(NAME,KEYWORD) \
56     NAME.setKeyword(KEYWORD); \
57     parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME));
58 gezelter 2
59 tim 665 #define DefineOptionalParameter(NAME,KEYWORD) \
60     NAME.setKeyword(KEYWORD); NAME.setOptional(true); \
61     parameters_.insert(std::make_pair(std::string(KEYWORD), &NAME));
62 chrisfen 417
63 tim 665 #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 tim 672 #define CheckParameter(NAME, CONSTRAINT) \
68 tim 674 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 tim 672
70 gezelter 2 Globals::Globals(){
71 tim 665
72     DefineParameter(ForceField, "forceField")
73     DefineParameter(NComponents, "nComponents")
74    
75     DefineOptionalParameter(TargetTemp, "targetTemp");
76     DefineOptionalParameter(Ensemble, "ensemble");
77     DefineOptionalParameter(Dt, "dt");
78     DefineOptionalParameter(RunTime, "runTime");
79     DefineOptionalParameter(InitialConfig, "initialConfig");
80     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");
87     DefineOptionalParameter(SampleTime, "sampleTime");
88     DefineOptionalParameter(ResetTime, "resetTime");
89     DefineOptionalParameter(StatusTime, "statusTime");
90     DefineOptionalParameter(CutoffRadius, "cutoffRadius");
91     DefineOptionalParameter(SwitchingRadius, "switchingRadius");
92     DefineOptionalParameter(Dielectric, "dielectric");
93     DefineOptionalParameter(TempSet, "tempSet");
94     DefineOptionalParameter(ThermalTime, "thermalTime");
95     DefineOptionalParameter(TargetPressure, "targetPressure");
96     DefineOptionalParameter(TauThermostat, "tauThermostat");
97     DefineOptionalParameter(TauBarostat, "tauBarostat");
98     DefineOptionalParameter(ZconsTime, "zconsTime");
99     DefineOptionalParameter(NZconstraints, "nZconstraints");
100     DefineOptionalParameter(ZconsTol, "zconsTol");
101     DefineOptionalParameter(ZconsForcePolicy, "zconsForcePolicy");
102     DefineOptionalParameter(Seed, "seed");
103     DefineOptionalParameter(Minimizer, "minimizer");
104     DefineOptionalParameter(MinimizerMaxIter,"minimizerMaxIter");
105     DefineOptionalParameter(MinimizerWriteFrq, "minimizerWriteFrq");
106     DefineOptionalParameter(MinimizerStepSize, "minimizerStepSize");
107     DefineOptionalParameter(MinimizerFTol, "minimizerFTol");
108     DefineOptionalParameter(MinimizerGTol, "minimizerGTol");
109     DefineOptionalParameter(MinimizerLSTol, "minimizerLSTol");
110     DefineOptionalParameter(MinimizerLSMaxIter, "minimizerLSMaxIter");
111     DefineOptionalParameter(ZconsGap, "zconsGap");
112     DefineOptionalParameter(ZconsFixtime, "zconsFixtime");
113     DefineOptionalParameter(ZconsUsingSMD, "zconsUsingSMD");
114     DefineOptionalParameter(ThermodynamicIntegrationLambda, "thermodynamicIntegrationLambda");
115     DefineOptionalParameter(ThermodynamicIntegrationK, "thermodynamicIntegrationK");
116     DefineOptionalParameter(ForceFieldVariant, "forceFieldVariant");
117     DefineOptionalParameter(ForceFieldFileName, "forceFieldFileName");
118     DefineOptionalParameter(ThermIntDistSpringConst, "thermIntDistSpringConst");
119     DefineOptionalParameter(ThermIntThetaSpringConst, "thermIntThetaSpringConst");
120     DefineOptionalParameter(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst");
121     DefineOptionalParameter(SurfaceTension, "surfaceTension");
122     DefineOptionalParameter(PrintPressureTensor, "printPressureTensor");
123     DefineOptionalParameter(ElectrostaticSummationMethod, "electrostaticSummationMethod");
124 chrisfen 710 DefineOptionalParameter(ScreeningMethod, "screeningMethod");
125 tim 665 DefineOptionalParameter(CutoffPolicy, "cutoffPolicy");
126    
127     DefineOptionalParameterWithDefaultValue(MixingRule, "mixingRule", "standard");
128     DefineOptionalParameterWithDefaultValue(UsePeriodicBoundaryConditions, "usePeriodicBoundaryConditions", true);
129     DefineOptionalParameterWithDefaultValue(UseInitalTime, "useInitialTime", false);
130     DefineOptionalParameterWithDefaultValue(UseIntialExtendedSystemState, "useInitialExtendedSystemState", false);
131     DefineOptionalParameterWithDefaultValue(OrthoBoxTolerance, "orthoBoxTolerance", 1E-6);
132     DefineOptionalParameterWithDefaultValue(UseSolidThermInt, "useSolidThermInt", false);
133     DefineOptionalParameterWithDefaultValue(UseLiquidThermInt, "useLiquidThermInt", false);
134 chrisfen 666 DefineOptionalParameterWithDefaultValue(ThermIntDistSpringConst, "thermIntDistSpringConst", 6.0);
135     DefineOptionalParameterWithDefaultValue(ThermIntThetaSpringConst, "thermIntThetaSpringConst", 7.5);
136     DefineOptionalParameterWithDefaultValue(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst", 13.5);
137 tim 665 DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 1.5);
138     DefineOptionalParameterWithDefaultValue(CompressDumpFile, "compressDumpFile", 0);
139     DefineOptionalParameterWithDefaultValue(SkinThickness, "skinThickness", 1.0);
140 tim 681 DefineOptionalParameterWithDefaultValue(StatFileFormat, "statFileFormat", "TIME|TOTAL_ENERGY|POTENTIAL_ENERGY|KINETIC_ENERGY|TEMPERATURE|PRESSURE|VOLUME|CONSERVED_QUANTITY");
141    
142 tim 665
143 gezelter 2 }
144    
145 tim 665 int Globals::globalAssign( event* the_event ){
146 tim 674 char errorMessage[65535];
147 tim 665 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 chrisfen 417
152 tim 673 bool result = false;
153 gezelter 2
154 tim 674 /**@todo fix memory leak */
155 tim 665 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 tim 674 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 tim 665 }
163     } else if( the_type == DOUBLE ){
164     result = i->second->setData(the_event->evt.asmt.rhs.dval);
165     if (!result )
166 tim 674 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 tim 665 }
169     else if (the_type == INT ){
170     result = i->second->setData(the_event->evt.asmt.rhs.ival);
171     if (!result )
172 tim 674 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 tim 665
175     } else {
176 tim 674 sprintf(errorMessage, "Internal error of parser\n");
177     the_event->err_msg = strdup(errorMessage);
178 tim 665 }
179 tim 674 } else {
180     sprintf(errorMessage, "%s is an unrecognized keyword\n", keyword.c_str() );
181     the_event->err_msg = strdup(errorMessage);
182 tim 665 }
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 gezelter 2
190 tim 665 return result;
191 gezelter 2 }
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 tim 665 if( haveNComponents() && index < getNComponents() )
200 gezelter 2 components[index] = current_component;
201     else{
202 tim 665 if( haveNComponents() ){
203 gezelter 2 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;
255    
256     return 1;
257     }
258    
259     int Globals::newZconstraint( event* the_event ){
260    
261    
262     int index = the_event->evt.blk_index;
263     char err[200];
264     current_zConstraint = new ZconStamp( index );
265    
266 tim 665 if( haveNZconstraints() && index < getNZconstraints() )
267 gezelter 2 zConstraints[index] = current_zConstraint;
268     else{
269 tim 665 if( haveNZconstraints() ){
270 gezelter 2 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 tim 665
283 gezelter 2 return 1;
284     }
285    
286    
287    
288     int Globals::zConstraintAssign( event* the_event ){
289    
290     switch( the_event->evt.asmt.asmt_type ){
291    
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;
317     }
318    
319     int Globals::zConstraintEnd( event* the_event ){
320    
321     the_event->err_msg = current_zConstraint->checkMe();
322     if( the_event->err_msg != NULL ) return 0;
323    
324     return 1;
325     }
326    
327 tim 665 char* Globals::checkMe( void ){
328 tim 425
329 gezelter 2
330 tim 665 std::string err("The following required keywords are missing:\n");
331     short int have_err = 0;
332 gezelter 2
333 tim 665 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 gezelter 2 }
338     }
339    
340 tim 672 CheckParameter(ForceField, isNotEmpty());
341     CheckParameter(NComponents,isPositive());
342     CheckParameter(TargetTemp, isPositive());
343     CheckParameter(Ensemble, isEqualIgnoreCase(std::string("NVE")) || isEqualIgnoreCase(std::string("NVT")) ||
344     isEqualIgnoreCase(std::string("NPTi")) || isEqualIgnoreCase(std::string("NPTf"))||
345     isEqualIgnoreCase(std::string("NPTxyz")) );
346     CheckParameter(Dt, isPositive());
347     CheckParameter(RunTime, isPositive());
348     CheckParameter(InitialConfig, isNotEmpty());
349     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());
356     CheckParameter(SampleTime, isNonNegative());
357     CheckParameter(ResetTime, isNonNegative());
358     CheckParameter(StatusTime, isNonNegative());
359     CheckParameter(CutoffRadius, isPositive());
360     CheckParameter(SwitchingRadius, isNonNegative());
361     CheckParameter(Dielectric, isPositive());
362     CheckParameter(ThermalTime, isNonNegative());
363     CheckParameter(TargetPressure, isPositive());
364     CheckParameter(TauThermostat, isPositive());
365     CheckParameter(TauBarostat, isPositive());
366     CheckParameter(ZconsTime, isPositive());
367     CheckParameter(NZconstraints, isPositive());
368     CheckParameter(ZconsTol, isPositive());
369     //CheckParameter(ZconsForcePolicy,);
370     CheckParameter(Seed, isPositive());
371     CheckParameter(Minimizer, isEqualIgnoreCase(std::string("SD")) || isEqualIgnoreCase(std::string("CG")));
372     CheckParameter(MinimizerMaxIter, isPositive());
373     CheckParameter(MinimizerWriteFrq, isPositive());
374     CheckParameter(MinimizerStepSize, isPositive());
375     CheckParameter(MinimizerFTol, isPositive());
376     CheckParameter(MinimizerGTol, isPositive());
377     CheckParameter(MinimizerLSTol, isPositive());
378     CheckParameter(MinimizerLSMaxIter, isPositive());
379     CheckParameter(ZconsGap, isPositive());
380     CheckParameter(ZconsFixtime, isPositive());
381     CheckParameter(ThermodynamicIntegrationLambda, isPositive());
382     CheckParameter(ThermodynamicIntegrationK, isPositive());
383     CheckParameter(ForceFieldVariant, isNotEmpty());
384     CheckParameter(ForceFieldFileName, isNotEmpty());
385     CheckParameter(ThermIntDistSpringConst, isPositive());
386     CheckParameter(ThermIntThetaSpringConst, isPositive());
387     CheckParameter(ThermIntOmegaSpringConst, isPositive());
388     CheckParameter(SurfaceTension, isPositive());
389 chrisfen 710 CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase(std::string("NONE")) || isEqualIgnoreCase(std::string("SHIFTED_POTENTIAL")) || isEqualIgnoreCase(std::string("SHIFTED_FORCE")) || isEqualIgnoreCase(std::string("REACTION_FIELD")));
390     CheckParameter(ScreeningMethod, isEqualIgnoreCase(std::string("UNDAMPED")) || isEqualIgnoreCase(std::string("DAMPED")));
391 tim 672 CheckParameter(CutoffPolicy, isEqualIgnoreCase(std::string("MIX")) || isEqualIgnoreCase(std::string("MAX")) || isEqualIgnoreCase(std::string("TRADITIONAL")));
392     //CheckParameter(StatFileFormat,);
393     //CheckParameter(MixingRule,);
394     CheckParameter(OrthoBoxTolerance, isPositive());
395     CheckParameter(ThermIntDistSpringConst, isPositive());
396     CheckParameter(ThermIntThetaSpringConst, isPositive());
397     CheckParameter(ThermIntOmegaSpringConst, isPositive());
398     CheckParameter(DampingAlpha,isPositive());
399     CheckParameter(SkinThickness, isPositive());
400    
401 tim 665 //@todo memory leak
402     if( have_err )
403     return strdup( err.c_str() );
404 gezelter 2
405 tim 665 return NULL;
406 gezelter 2
407    
408     }
409    
410     int Globals::globalEnd( event* the_event ){
411    
412     the_event->err_msg = checkMe();
413     if( the_event->err_msg != NULL ) return 0;
414    
415     return 1;
416     }