ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/io/Globals.hpp
(Generate patch)

Comparing trunk/src/io/Globals.hpp (file contents):
Revision 536 by tim, Thu May 19 04:28:26 2005 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 6 | Line 6
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
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
12 > * 2. Redistributions in binary form must reproduce the above copyright
13   *    notice, this list of conditions and the following disclaimer in the
14   *    documentation and/or other materials provided with the
15   *    distribution.
# Line 37 | Line 28
28   * arising out of the use of or inability to use software, even if the
29   * University of Notre Dame has been advised of the possibility of
30   * such damages.
31 + *
32 + * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33 + * research, please cite the appropriate papers when you publish your
34 + * work.  Good starting points are:
35 + *                                                                      
36 + * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37 + * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38 + * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 + * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41  
42   #ifndef IO_GLOBALS_HPP
# Line 49 | Line 49
49   #include <string>
50   #include <map>
51  
52 – #include "io/BASS_interface.h"
52   #include "types/Component.hpp"
53 < #include "types/MakeStamps.hpp"
54 < #include "types/ZconStamp.hpp"
53 > #include "types/ZconsStamp.hpp"
54 > #include "types/RestraintStamp.hpp"
55 > #include "types/MoleculeStamp.hpp"
56 > #include "utils/ParameterManager.hpp"
57  
58 + namespace OpenMD {
59 +  class Globals : public DataHolder {
60 +  public:
61 +    typedef std::pair<int, int> intPair;
62  
63 +    Globals();
64 +    virtual ~Globals();
65 +    
66 +    DeclareParameter(ForceField, std::string);
67 +    DeclareParameter(TargetTemp, RealType);
68 +    DeclareParameter(Ensemble, std::string);
69 +    DeclareParameter(Dt, RealType);
70 +    DeclareParameter(RunTime, RealType);
71 +    DeclareParameter(FinalConfig, std::string);
72 +    DeclareParameter(SampleTime, RealType);
73 +    DeclareParameter(ResetTime, RealType);
74 +    DeclareParameter(StatusTime, RealType);
75 +    DeclareParameter(CutoffRadius, RealType);
76 +    DeclareParameter(SwitchingRadius, RealType);
77 +    DeclareParameter(TempSet, bool);
78 +    DeclareParameter(ThermalTime, RealType);
79 +    DeclareParameter(UsePeriodicBoundaryConditions, bool);
80 +    DeclareParameter(TargetPressure, RealType);
81 +    DeclareParameter(UseAtomicVirial, bool);
82 +    DeclareParameter(TauThermostat, RealType);
83 +    DeclareParameter(TauBarostat, RealType);
84 +    DeclareParameter(ZconsTime, RealType);
85 +    DeclareParameter(ZconsTol, RealType);
86 +    DeclareParameter(ZconsForcePolicy, std::string);
87 +    DeclareParameter(Seed, unsigned long int);
88 +    DeclareParameter(UseInitalTime, bool);
89 +    DeclareParameter(UseIntialExtendedSystemState, bool);
90 +    DeclareParameter(OrthoBoxTolerance, RealType);
91 +    DeclareParameter(Minimizer, std::string);
92 +    DeclareParameter(MinimizerMaxIter, RealType);
93 +    DeclareParameter(MinimizerWriteFrq, int);
94 +    DeclareParameter(MinimizerStepSize, RealType);
95 +    DeclareParameter(MinimizerFTol, RealType);
96 +    DeclareParameter(MinimizerGTol, RealType);
97 +    DeclareParameter(MinimizerLSTol, RealType);
98 +    DeclareParameter(MinimizerLSMaxIter, int);
99 +    DeclareParameter(ZconsGap, RealType);
100 +    DeclareParameter(ZconsFixtime, RealType);
101 +    DeclareParameter(ZconsUsingSMD, bool);
102 +    DeclareParameter(UseThermodynamicIntegration, bool);
103 +    DeclareParameter(ThermodynamicIntegrationLambda, RealType);
104 +    DeclareParameter(ThermodynamicIntegrationK, RealType);
105 +    DeclareParameter(ForceFieldVariant, std::string);
106 +    DeclareParameter(ForceFieldFileName, std::string);
107 +    DeclareParameter(SurfaceTension, RealType);
108 +    DeclareParameter(PrintPressureTensor, bool);
109 +    DeclareParameter(TaggedAtomPair, intPair);
110 +    DeclareParameter(PrintTaggedPairDistance, bool);
111 +    DeclareParameter(ElectrostaticSummationMethod, std::string);
112 +    DeclareParameter(ElectrostaticScreeningMethod, std::string);
113 +    DeclareParameter(DampingAlpha, RealType);
114 +    DeclareParameter(Dielectric, RealType);
115 +    DeclareParameter(CutoffPolicy, std::string);
116 +    DeclareParameter(SwitchingFunctionType, std::string);
117 +    DeclareParameter(CompressDumpFile, bool);
118 +    DeclareParameter(OutputForceVector, bool);
119 +    DeclareParameter(SkinThickness, RealType);
120 +    DeclareParameter(StatFileFormat, std::string);    
121 +    DeclareParameter(HydroPropFile, std::string);
122 +    DeclareParameter(Viscosity, RealType);
123 +    DeclareParameter(BeadSize, RealType);  
124 +    DeclareParameter(ThermalConductivity, RealType);
125 +    DeclareParameter(ThermalLength, RealType);
126 +    DeclareParameter(UseSphericalBoundaryConditions, bool);
127 +    DeclareParameter(FrozenBufferRadius, RealType);
128 +    DeclareParameter(LangevinBufferRadius, RealType);
129 +    DeclareParameter(AccumulateBoxDipole, bool);
130 +    DeclareParameter(NeighborListNeighbors, int);
131 +    DeclareParameter(UseMultipleTemperatureMethod, bool);
132 +    DeclareParameter(MTM_Ce, RealType);
133 +    DeclareParameter(MTM_G, RealType);
134 +    DeclareParameter(MTM_Io, RealType);
135 +    DeclareParameter(MTM_Sigma, RealType);    
136 +    DeclareParameter(MTM_R, RealType);    
137 +    DeclareParameter(UseRNEMD, bool);
138 +    DeclareParameter(RNEMD_exchangeTime, RealType);
139 +    DeclareParameter(RNEMD_nBins, int);
140 +    DeclareParameter(RNEMD_logWidth, int);
141 +    DeclareParameter(RNEMD_exchangeType, std::string);
142 +    DeclareParameter(RNEMD_objectSelection, std::string);
143 +    DeclareParameter(RNEMD_targetFlux, RealType);
144 +    DeclareParameter(UseRestraints, bool);
145 +    DeclareParameter(Restraint_file, std::string);
146 +    
147 +  public:
148 +    bool addComponent(Component* comp);
149 +    bool addZConsStamp(ZConsStamp* zcons);
150 +    bool addRestraintStamp(RestraintStamp* rest);
151 +    bool addMoleculeStamp(MoleculeStamp* molStamp);
152 +    int getNComponents() {return components_.size();}
153 +    std::vector<Component*> getComponents() {return components_;}
154 +    Component* getComponentAt(int index) {return components_.at(index);}    
155 +    
156 +    int getNZconsStamps() {return zconstraints_.size();}
157 +    std::vector<ZConsStamp*> getZconsStamps() {return zconstraints_;}
158 +    ZConsStamp* getZconsStampAt(int index) {return zconstraints_.at(index);}    
159  
160 < /**
161 < * @class Globals Globals.hpp "io/Globals.hpp"
162 < * @brief parsing and storing global parameters for simulation
62 < * @todo need refactorying
63 < */
64 < class Globals{
65 <  
66 < public:
67 <  
68 <  Globals();
69 <  ~Globals();
160 >    int getNRestraintStamps() {return restraints_.size();}
161 >    std::vector<RestraintStamp*> getRestraintStamps() {return restraints_;}
162 >    RestraintStamp* getRestraintStampAt(int index) {return restraints_.at(index);}    
163  
164 <  void initalize();
165 <  
166 <  int newComponent( event* the_event );
167 <  int componentAssign( event* the_event );
168 <  int componentEnd( event* the_event );
169 <
170 <  int newZconstraint( event* the_event );
171 <  int zConstraintAssign( event* the_event );
172 <  int zConstraintEnd( event* the_event );
173 <  
81 <  int globalAssign( event* the_event );
82 <  int globalEnd( event* the_event );
83 <
84 <  char*  getForceField( void )      { return force_field; }
85 <  int    getNComponents( void )     { return n_components; }
86 <  double getTargetTemp( void )      { return target_temp; }
87 <  double getTargetPressure( void )  { return target_pressure; }
88 <  double getQmass( void )           { return q_mass; }
89 <  double getTauThermostat( void )   { return tau_thermostat; }
90 <  double getTauBarostat( void )     { return tau_barostat; }
91 <  char*  getEnsemble( void )        { return ensemble; }
92 <  double getDt( void )              { return dt; }
93 <  double getRunTime( void )         { return run_time; }
94 <
95 <  int    getNzConstraints( void )   { return n_zConstraints; }
96 <  char*  getInitialConfig( void )   { return initial_config; }
97 <  char*  getFinalConfig( void )     { return final_config; }
98 <  int    getNMol( void )            { return n_mol; }
99 <  double getDensity( void )         { return density; }
100 <  double getBox( void )             { return box; }
101 <  double getBoxX( void )            { return box_x; }
102 <  double getBoxY( void )            { return box_y; }
103 <  double getBoxZ( void )            { return box_z; }
104 <  double getSampleTime( void )      { return sample_time; }
105 <  double getStatusTime( void )      { return status_time; }
106 <  double getResetTime( void )       { return resetTime; }
107 <  double getThermalTime( void )     { return thermal_time; }
108 <  double getDielectric( void )      { return dielectric; }
109 <  double getRcut( void )            { return rcut; }
110 <  double getRsw( void )             { return rsw; }
111 <  int    getTempSet( void )         { return tempSet; }
112 <  int    getUseInitTime( void )     { return useInitTime; }
113 <  int    getUseInitXSstate( void )  { return useInitXSstate; }
114 <  double getOrthoBoxTolerance(void) { return orthoBoxTolerance; }
115 <  int    getPBC( void )             { return usePBC; }
116 <  int    getUseRF( void )           { return useRF; }
117 <  char*  getMixingRule( void)       { return mixingRule; }
118 <  double getZconsTime(void)         { return zcons_time; }
119 <  double getZconsTol(void)          { return zcons_tol; }
120 <  char*  getZconsForcePolicy(void)  { return zconsForcePolicy; }
121 <  double getZconsGap(void)          { return zcons_gap; }
122 <  double getZconsFixtime(void)      { return zcons_fixtime; }
123 <  int    getZconsUsingSMD(void)     { return zcons_using_smd; }
124 <  int    getSeed(void)              { return seed; }
125 <  char*  getMinimizer(void)         { return minimizer_name; }
126 <  int    getMinMaxIter(void)        { return minimizer_maxiteration; }
127 <  int    getMinWriteFrq(void)       { return minimizer_writefrq; }
128 <  double getMinStepSize(void)       { return minimizer_stepsize; }
129 <  double getMinFTol(void)           { return minimizer_ftol; }
130 <  double getMinGTol(void)           { return minimizer_gtol; }
131 <  double getMinLSTol(void)          { return minimizer_ls_tol; }
132 <  int    getMinLSMaxIter(void)      { return minimizer_ls_maxiteration; }
133 <  int    getUseSolidThermInt(void)  { return useSolidThermInt; }
134 <  int    getUseLiquidThermInt(void) { return useLiquidThermInt; }
135 <  double getThermIntLambda(void)   { return thermodynamic_integration_lambda; }
136 <  double getThermIntK(void)         { return thermodynamic_integration_k; }
137 <  char*  getForceFieldVariant( void ) { return forcefield_variant; }
138 <  char* getForceFieldFileName() { return forcefield_filename;}
139 <  double getDistSpringConst(void)   { return therm_int_dist_spring; }
140 <  double getThetaSpringConst(void)  { return therm_int_theta_spring; }
141 <  double getOmegaSpringConst(void)  { return therm_int_omega_spring; }
142 <  double getTargetStress(void) {return target_stress; }
143 <  
144 <  short int haveDt( void )            { return have_dt; }
145 <  short int haveRunTime( void )       { return have_run_time; }
146 <  short int haveEnsemble( void )      { return have_ensemble; }
147 <  short int haveTargetTemp( void )    { return have_target_temp; }
148 <  short int haveInitialConfig( void ) { return have_initial_config; }
149 <  short int haveFinalConfig( void )   { return have_final_config; }
150 <  short int haveNMol( void )          { return have_n_mol; }
151 <  short int haveDensity( void )       { return have_density; }
152 <  short int haveBox( void )           { return have_box; }
153 <  short int haveBoxX( void )          { return have_box_x; }
154 <  short int haveBoxY( void )          { return have_box_y; }
155 <  short int haveBoxZ( void )          { return have_box_z; }
156 <  short int haveSampleTime( void )    { return have_sample_time; }
157 <  short int haveResetTime( void )     { return have_reset_time; }
158 <  short int haveStatusTime( void )    { return have_status_time; }
159 <  short int haveThermalTime( void )   { return have_thermal_time; }
160 <  short int haveRcut( void )          { return have_rcut; }
161 <  short int haveRsw( void )           { return have_rsw; }
162 <  short int haveDielectric( void )    { return have_dielectric; }
163 <  short int haveTempSet( void )       { return have_tempSet; }
164 <  short int haveTargetPressure( void ){ return have_target_pressure; }
165 <  short int haveQmass( void )         { return have_q_mass; }
166 <  short int haveTauThermostat( void ) { return have_tau_thermostat; }
167 <  short int haveTauBarostat( void )   { return have_tau_barostat; }
168 <  short int haveZconstraintTime(void) { return have_zcons_time; }
169 <  short int haveZconstraints( void )  { return have_zConstraints; }
170 <  short int haveZconsTol(void)        { return have_zcons_tol; }
171 <  short int haveZconsForcePolicy(void){ return have_zcons_force_policy; }
172 <  short int haveZConsGap(void)        { return have_zcons_gap; }
173 <  short int haveZConsFixTime(void)    { return have_zcons_fixtime; }
174 <  short int haveZConsUsingSMD(void)   { return have_zcons_using_smd; }  
175 <  short int haveSeed(void)            { return have_seed; }
176 <  short int haveMinimizer(void)       { return have_minimizer; }
177 <  short int haveMinMaxIter(void)      { return have_minimizer_maxiteration; }
178 <  short int haveMinWriteFrq(void)     { return have_minimizer_writefrq; }
179 <  short int haveMinStepSize(void)     { return have_minimizer_stepsize; }
180 <  short int haveMinFTol(void)         { return have_minimizer_ftol; }
181 <  short int haveMinGTol(void)         { return have_minimizer_gtol; }
182 <  short int haveMinLSTol(void)        { return have_minimizer_ls_tol; }
183 <  short int haveMinLSMaxIter(void)    { return have_minimizer_ls_maxiteration;}
184 <  short int haveThermIntLambda(void)  { return have_thermodynamic_integration_lambda; }
185 <  short int haveThermIntK(void)    { return have_thermodynamic_integration_k; }
186 <  short int haveForceFieldVariant(void) { return have_forcefield_variant; }
187 <  short int haveForceFieldFileName(void) { return have_forcefield_filename; }
188 <  short int haveDistSpringConst(void) { return have_dist_spring_constant; }
189 <  short int haveThetaSpringConst(void) { return have_theta_spring_constant; }
190 <  short int haveOmegaSpringConst(void) { return have_omega_spring_constant; }
191 <  short int haveTargetStress(void) { return have_targetstress; }
192 <  /* other accessors */
193 <  Component** getComponents( void )   { return components; }
194 <  ZconStamp** getZconStamp( void )    { return zConstraints; }
195 <  
196 < private:
197 <  
198 <
199 <  typedef std::map<std::string, int> CommandMapType;
200 <  CommandMapType command_table;
201 <
202 <  
203 <  char* checkMe( void );
204 <  
205 <  Component* current_component;
206 <  Component** components; // the array of components
207 <
208 <  ZconStamp* current_zConstraint;
209 <  ZconStamp** zConstraints; // the array of zConstraints
210 <
211 <  char force_field[100];
212 <  int n_components;
213 <  int n_zConstraints;
214 <  double target_temp;
215 <  double target_pressure;
216 <  char ensemble[100];
217 <  char mixingRule[100];
218 <  double dt;
219 <  double run_time;
220 <  char initial_config[120];
221 <  char final_config[120];
222 <  int n_mol;
223 <  double density;
224 <  double box;
225 <  double box_x, box_y, box_z;
226 <  double sample_time;
227 <  double status_time;
228 <  double resetTime;
229 <  double orthoBoxTolerance;
230 <  double thermal_time;
231 <  double rcut;
232 <  double rsw;
233 <  double dielectric;
234 <  int tempSet;
235 <  int useInitTime;
236 <  int useInitXSstate;
237 <  int usePBC;
238 <  int useRF;
239 <  double q_mass;
240 <  double tau_thermostat;
241 <  double tau_barostat;
242 <  double zcons_time;    
243 <  double zcons_tol;
244 <  char zconsForcePolicy[100];
245 <  double zcons_gap;
246 <  double zcons_fixtime;
247 <  int zcons_using_smd;
248 <  
249 <  int seed;
250 <  char minimizer_name[100];
251 <  int minimizer_maxiteration;
252 <  int minimizer_writefrq;
253 <  double minimizer_stepsize;
254 <  double minimizer_ftol;
255 <  double minimizer_gtol;
256 <  double minimizer_ls_tol;
257 <  int minimizer_ls_maxiteration;
258 <  int useSolidThermInt;
259 <  int useLiquidThermInt;
260 <  double thermodynamic_integration_lambda;
261 <  double thermodynamic_integration_k;
262 <  char forcefield_variant[100];
263 <  char forcefield_filename[100];
264 <  double therm_int_dist_spring;
265 <  double therm_int_theta_spring;
266 <  double therm_int_omega_spring;
267 <  double target_stress;
268 <  
269 <  //required arguments
270 <  short int have_force_field, have_n_components, have_target_temp;
271 <  short int have_target_pressure, have_ensemble, have_dt, have_run_time;
272 <  
273 <  // optional arguments
274 <  short int have_initial_config, have_final_config, have_n_mol;
275 <  short int have_density, have_box, have_box_x, have_box_y, have_box_z;
276 <  short int have_sample_time, have_status_time, have_rcut, have_dielectric;
277 <  short int have_tempSet, have_thermal_time, have_rsw, have_q_mass;
278 <  short int have_tau_thermostat, have_tau_barostat;
279 <  short int have_zcons_time, have_zConstraints, have_n_zConstraints;
280 <  short int have_zcons_tol, have_seed;
281 <  short int have_zcons_force_policy, have_reset_time;
282 <  short int have_zcons_gap, have_zcons_fixtime;
283 <  short int have_zcons_using_smd;
284 <  short int have_minimizer, have_minimizer_maxiteration;
285 <  short int have_minimizer_writefrq, have_minimizer_stepsize;
286 <  short int have_minimizer_ftol, have_minimizer_gtol;
287 <  short int have_minimizer_ls_tol, have_minimizer_ls_maxiteration;
288 <  short int have_thermodynamic_integration_lambda;
289 <  short int have_thermodynamic_integration_k;
290 <  short int have_forcefield_variant;
291 <  short int have_forcefield_filename;  
292 <  short int have_dist_spring_constant;
293 <  short int have_theta_spring_constant;
294 <  short int have_omega_spring_constant;
295 <  short int have_targetstress;
164 >    //std::string getRestraint_file(){
165 >    
166 >    virtual void validate();
167 >  private:
168 >    
169 >    std::vector<Component*> components_;
170 >    std::vector<ZConsStamp*> zconstraints_;    
171 >    std::vector<RestraintStamp*> restraints_;    
172 >    std::map<std::string, MoleculeStamp*> moleculeStamps_;
173 >    std::pair<int, int> taggedAtomPair_;
174   };
175 <
175 > }
176   #endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines