ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/io/Globals.cpp
Revision: 705
Committed: Tue Nov 1 19:14:27 2005 UTC (19 years, 6 months ago) by chrisfen
File size: 16786 byte(s)
Log Message: 
fixed a capitalization problem with NPT integrator initialization

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     DefineOptionalParameter(CutoffPolicy, "cutoffPolicy");
125    
126     DefineOptionalParameterWithDefaultValue(MixingRule, "mixingRule", "standard");
127     DefineOptionalParameterWithDefaultValue(UsePeriodicBoundaryConditions, "usePeriodicBoundaryConditions", true);
128     DefineOptionalParameterWithDefaultValue(UseInitalTime, "useInitialTime", false);
129     DefineOptionalParameterWithDefaultValue(UseIntialExtendedSystemState, "useInitialExtendedSystemState", false);
130     DefineOptionalParameterWithDefaultValue(OrthoBoxTolerance, "orthoBoxTolerance", 1E-6);
131     DefineOptionalParameterWithDefaultValue(UseSolidThermInt, "useSolidThermInt", false);
132     DefineOptionalParameterWithDefaultValue(UseLiquidThermInt, "useLiquidThermInt", false);
133 chrisfen 666 DefineOptionalParameterWithDefaultValue(ThermIntDistSpringConst, "thermIntDistSpringConst", 6.0);
134     DefineOptionalParameterWithDefaultValue(ThermIntThetaSpringConst, "thermIntThetaSpringConst", 7.5);
135     DefineOptionalParameterWithDefaultValue(ThermIntOmegaSpringConst, "thermIntOmegaSpringConst", 13.5);
136 tim 665 DefineOptionalParameterWithDefaultValue(DampingAlpha, "dampingAlpha", 1.5);
137     DefineOptionalParameterWithDefaultValue(CompressDumpFile, "compressDumpFile", 0);
138     DefineOptionalParameterWithDefaultValue(SkinThickness, "skinThickness", 1.0);
139 tim 681 DefineOptionalParameterWithDefaultValue(StatFileFormat, "statFileFormat", "TIME|TOTAL_ENERGY|POTENTIAL_ENERGY|KINETIC_ENERGY|TEMPERATURE|PRESSURE|VOLUME|CONSERVED_QUANTITY");
140    
141 tim 665
142 gezelter 2 }
143    
144 tim 665 int Globals::globalAssign( event* the_event ){
145 tim 674 char errorMessage[65535];
146 tim 665 int key;
147     interface_assign_type the_type = the_event->evt.asmt.asmt_type;
148     char* lhs = the_event->evt.asmt.lhs;
149     std::string keyword(lhs);
150 chrisfen 417
151 tim 673 bool result = false;
152 gezelter 2
153 tim 674 /**@todo fix memory leak */
154 tim 665 ParamMap::iterator i =parameters_.find(keyword);
155     if (i != parameters_.end()) {
156     if( the_type == STRING ){
157     result = i->second->setData(std::string(the_event->evt.asmt.rhs.sval));
158     if (!result ) {
159 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);
160     the_event->err_msg = strdup(errorMessage);
161 tim 665 }
162     } else if( the_type == DOUBLE ){
163     result = i->second->setData(the_event->evt.asmt.rhs.dval);
164     if (!result )
165 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 );
166     the_event->err_msg = strdup(errorMessage);
167 tim 665 }
168     else if (the_type == INT ){
169     result = i->second->setData(the_event->evt.asmt.rhs.ival);
170     if (!result )
171 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 );
172     the_event->err_msg = strdup(errorMessage);
173 tim 665
174     } else {
175 tim 674 sprintf(errorMessage, "Internal error of parser\n");
176     the_event->err_msg = strdup(errorMessage);
177 tim 665 }
178 tim 674 } else {
179     sprintf(errorMessage, "%s is an unrecognized keyword\n", keyword.c_str() );
180     the_event->err_msg = strdup(errorMessage);
181 tim 665 }
182    
183     if (keyword == "nComponents" && getNComponents() > 0) {
184     components = new Component*[getNComponents()];
185     }else if (keyword == "nZconstraints" && getNZconstraints() > 0) {
186     zConstraints = new ZconStamp*[getNZconstraints()];
187     }
188 gezelter 2
189 tim 665 return result;
190 gezelter 2 }
191    
192     int Globals::newComponent( event* the_event ){
193    
194     current_component = new Component;
195     int index = the_event->evt.blk_index;
196     char err[200];
197    
198 tim 665 if( haveNComponents() && index < getNComponents() )
199 gezelter 2 components[index] = current_component;
200     else{
201 tim 665 if( haveNComponents() ){
202 gezelter 2 sprintf( err, "meta-data parsing error: %d out of nComponents range",
203     index );
204     the_event->err_msg = strdup( err );
205     return 0;
206     }
207     else{
208     the_event->err_msg = strdup("meta-data parsing error: nComponents not given before"
209     " first component declaration." );
210     return 0;
211     }
212     }
213    
214     return 1;
215     }
216    
217    
218    
219     int Globals::componentAssign( event* the_event ){
220    
221     switch( the_event->evt.asmt.asmt_type ){
222    
223     case STRING:
224     return current_component->assignString( the_event->evt.asmt.lhs,
225     the_event->evt.asmt.rhs.sval,
226     &(the_event->err_msg));
227     break;
228    
229     case DOUBLE:
230     return current_component->assignDouble( the_event->evt.asmt.lhs,
231     the_event->evt.asmt.rhs.dval,
232     &(the_event->err_msg));
233     break;
234    
235     case INT:
236     return current_component->assignInt( the_event->evt.asmt.lhs,
237     the_event->evt.asmt.rhs.ival,
238     &(the_event->err_msg));
239     break;
240    
241     default:
242     the_event->err_msg = strdup( "Globals error. Invalid component"
243     " assignment type" );
244     return 0;
245     break;
246     }
247     return 0;
248     }
249    
250     int Globals::componentEnd( event* the_event ){
251    
252     the_event->err_msg = current_component->checkMe();
253     if( the_event->err_msg != NULL ) return 0;
254    
255     return 1;
256     }
257    
258     int Globals::newZconstraint( event* the_event ){
259    
260    
261     int index = the_event->evt.blk_index;
262     char err[200];
263     current_zConstraint = new ZconStamp( index );
264    
265 tim 665 if( haveNZconstraints() && index < getNZconstraints() )
266 gezelter 2 zConstraints[index] = current_zConstraint;
267     else{
268 tim 665 if( haveNZconstraints() ){
269 gezelter 2 sprintf( err, "meta-data parsing error: %d out of nZconstraints range",
270     index );
271     the_event->err_msg = strdup( err );
272     return 0;
273     }
274     else{
275     the_event->err_msg = strdup("meta-data parsing error: nZconstraints"
276     " not given before"
277     " first zConstraint declaration." );
278     return 0;
279     }
280     }
281 tim 665
282 gezelter 2 return 1;
283     }
284    
285    
286    
287     int Globals::zConstraintAssign( event* the_event ){
288    
289     switch( the_event->evt.asmt.asmt_type ){
290    
291     case STRING:
292     return current_zConstraint->assignString( the_event->evt.asmt.lhs,
293     the_event->evt.asmt.rhs.sval,
294     &(the_event->err_msg));
295     break;
296    
297     case DOUBLE:
298     return current_zConstraint->assignDouble( the_event->evt.asmt.lhs,
299     the_event->evt.asmt.rhs.dval,
300     &(the_event->err_msg));
301     break;
302    
303     case INT:
304     return current_zConstraint->assignInt( the_event->evt.asmt.lhs,
305     the_event->evt.asmt.rhs.ival,
306     &(the_event->err_msg));
307     break;
308    
309     default:
310     the_event->err_msg = strdup( "Globals error. Invalid zConstraint"
311     " assignment type" );
312     return 0;
313     break;
314     }
315     return 0;
316     }
317    
318     int Globals::zConstraintEnd( event* the_event ){
319    
320     the_event->err_msg = current_zConstraint->checkMe();
321     if( the_event->err_msg != NULL ) return 0;
322    
323     return 1;
324     }
325    
326 tim 665 char* Globals::checkMe( void ){
327 tim 425
328 gezelter 2
329 tim 665 std::string err("The following required keywords are missing:\n");
330     short int have_err = 0;
331 gezelter 2
332 tim 665 ParamMap::iterator i;
333     for (i = parameters_.begin(); i != parameters_.end(); ++i) {
334     if (!i->second->isOptional() && i->second->empty()) {
335     err += i->second->getKeyword() + "\n";
336 gezelter 2 }
337     }
338    
339 tim 672 CheckParameter(ForceField, isNotEmpty());
340     CheckParameter(NComponents,isPositive());
341     CheckParameter(TargetTemp, isPositive());
342     CheckParameter(Ensemble, isEqualIgnoreCase(std::string("NVE")) || isEqualIgnoreCase(std::string("NVT")) ||
343     isEqualIgnoreCase(std::string("NPTi")) || isEqualIgnoreCase(std::string("NPTf"))||
344     isEqualIgnoreCase(std::string("NPTxyz")) );
345     CheckParameter(Dt, isPositive());
346     CheckParameter(RunTime, isPositive());
347     CheckParameter(InitialConfig, isNotEmpty());
348     CheckParameter(FinalConfig, isNotEmpty());
349     CheckParameter(NMol, isPositive());
350     CheckParameter(Density, isPositive());
351     CheckParameter(Box, isPositive());
352     CheckParameter(BoxX, isPositive());
353     CheckParameter(BoxY, isPositive());
354     CheckParameter(BoxZ, isPositive());
355     CheckParameter(SampleTime, isNonNegative());
356     CheckParameter(ResetTime, isNonNegative());
357     CheckParameter(StatusTime, isNonNegative());
358     CheckParameter(CutoffRadius, isPositive());
359     CheckParameter(SwitchingRadius, isNonNegative());
360     CheckParameter(Dielectric, isPositive());
361     CheckParameter(ThermalTime, isNonNegative());
362     CheckParameter(TargetPressure, isPositive());
363     CheckParameter(TauThermostat, isPositive());
364     CheckParameter(TauBarostat, isPositive());
365     CheckParameter(ZconsTime, isPositive());
366     CheckParameter(NZconstraints, isPositive());
367     CheckParameter(ZconsTol, isPositive());
368     //CheckParameter(ZconsForcePolicy,);
369     CheckParameter(Seed, isPositive());
370     CheckParameter(Minimizer, isEqualIgnoreCase(std::string("SD")) || isEqualIgnoreCase(std::string("CG")));
371     CheckParameter(MinimizerMaxIter, isPositive());
372     CheckParameter(MinimizerWriteFrq, isPositive());
373     CheckParameter(MinimizerStepSize, isPositive());
374     CheckParameter(MinimizerFTol, isPositive());
375     CheckParameter(MinimizerGTol, isPositive());
376     CheckParameter(MinimizerLSTol, isPositive());
377     CheckParameter(MinimizerLSMaxIter, isPositive());
378     CheckParameter(ZconsGap, isPositive());
379     CheckParameter(ZconsFixtime, isPositive());
380     CheckParameter(ThermodynamicIntegrationLambda, isPositive());
381     CheckParameter(ThermodynamicIntegrationK, isPositive());
382     CheckParameter(ForceFieldVariant, isNotEmpty());
383     CheckParameter(ForceFieldFileName, isNotEmpty());
384     CheckParameter(ThermIntDistSpringConst, isPositive());
385     CheckParameter(ThermIntThetaSpringConst, isPositive());
386     CheckParameter(ThermIntOmegaSpringConst, isPositive());
387     CheckParameter(SurfaceTension, isPositive());
388     CheckParameter(ElectrostaticSummationMethod, isEqualIgnoreCase(std::string("NONE")) || isEqualIgnoreCase(std::string("UNDAMPED_WOLF")) || isEqualIgnoreCase(std::string("DAMPED_WOLF")) || isEqualIgnoreCase(std::string("REACTION_FIELD")) );
389     CheckParameter(CutoffPolicy, isEqualIgnoreCase(std::string("MIX")) || isEqualIgnoreCase(std::string("MAX")) || isEqualIgnoreCase(std::string("TRADITIONAL")));
390     //CheckParameter(StatFileFormat,);
391     //CheckParameter(MixingRule,);
392     CheckParameter(OrthoBoxTolerance, isPositive());
393     CheckParameter(ThermIntDistSpringConst, isPositive());
394     CheckParameter(ThermIntThetaSpringConst, isPositive());
395     CheckParameter(ThermIntOmegaSpringConst, isPositive());
396     CheckParameter(DampingAlpha,isPositive());
397     CheckParameter(SkinThickness, isPositive());
398    
399 tim 665 //@todo memory leak
400     if( have_err )
401     return strdup( err.c_str() );
402 gezelter 2
403 tim 665 return NULL;
404 gezelter 2
405    
406     }
407    
408     int Globals::globalEnd( event* the_event ){
409    
410     the_event->err_msg = checkMe();
411     if( the_event->err_msg != NULL ) return 0;
412    
413     return 1;
414     }