ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/src/io/Globals.hpp

Comparing:
trunk/src/io/Globals.hpp (file contents), Revision 3 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
branches/development/src/io/Globals.hpp (file contents), Revision 1729 by jmarr, Wed May 30 16:08:07 2012 UTC

#	Line 1 | Line 1
1	<	#ifndef __GLOBALS_H__
2	<	#define __GLOBALS_H__
1	>	/*
2	>	* Copyright (c) 2005, 2010 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. Redistributions of source code must retain the above copyright
10	>	*    notice, this list of conditions and the following disclaimer.
11	>	*
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.
16	>	*
17	>	* This software is provided "AS IS," without a warranty of any
18	>	* kind. All express or implied conditions, representations and
19	>	* warranties, including any implied warranty of merchantability,
20	>	* fitness for a particular purpose or non-infringement, are hereby
21	>	* excluded.  The University of Notre Dame and its licensors shall not
22	>	* be liable for any damages suffered by licensee as a result of
23	>	* using, modifying or distributing the software or its
24	>	* derivatives. In no event will the University of Notre Dame or its
25	>	* licensors be liable for any lost revenue, profit or data, or for
26	>	* direct, indirect, special, consequential, incidental or punitive
27	>	* damages, however caused and regardless of the theory of liability,
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]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40	>	* [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41	>	*/
42	>
43	>	#ifndef IO_GLOBALS_HPP
44	>	#define IO_GLOBALS_HPP
45
46		#include <iostream>
47
48		#include <stdlib.h>
49		#include <vector>
50	+	#include <string>
51	+	#include <map>
52
9	–	#include "io/BASS_interface.h"
53		#include "types/Component.hpp"
54	<	#include "io/LinkedCommand.hpp"
55	<	#include "types/MakeStamps.hpp"
56	<	#include "types/ZconStamp.hpp"
54	>	#include "types/ZconsStamp.hpp"
55	>	#include "types/RestraintStamp.hpp"
56	>	#include "types/MoleculeStamp.hpp"
57	>	#include "utils/ParameterManager.hpp"
58
59	<	using namespace std;
59	>	namespace OpenMD {
60	>	class Globals : public DataHolder {
61	>	public:
62	>	typedef std::pair<int, int> intPair;
63
64	<	class Globals{
65	<
66	<	public:
67	<
68	<	Globals();
69	<	~Globals();
64	>	Globals();
65	>	virtual ~Globals();
66	>
67	>	DeclareParameter(ForceField, std::string);
68	>	DeclareParameter(TargetTemp, RealType);
69	>	DeclareParameter(Ensemble, std::string);
70	>	DeclareParameter(Dt, RealType);
71	>	DeclareParameter(RunTime, RealType);
72	>	DeclareParameter(FinalConfig, std::string);
73	>	DeclareParameter(SampleTime, RealType);
74	>	DeclareParameter(ResetTime, RealType);
75	>	DeclareParameter(StatusTime, RealType);
76	>	DeclareParameter(CutoffRadius, RealType);
77	>	DeclareParameter(SwitchingRadius, RealType);
78	>	DeclareParameter(TempSet, bool);
79	>	DeclareParameter(ThermalTime, RealType);
80	>	DeclareParameter(UsePeriodicBoundaryConditions, bool);
81	>	DeclareParameter(TargetPressure, RealType);
82	>	DeclareParameter(UseAtomicVirial, bool);
83	>	DeclareParameter(TauThermostat, RealType);
84	>	DeclareParameter(TauBarostat, RealType);
85	>	DeclareParameter(ZconsTime, RealType);
86	>	DeclareParameter(ZconsTol, RealType);
87	>	DeclareParameter(ZconsForcePolicy, std::string);
88	>	DeclareParameter(Seed, unsigned long int);
89	>	DeclareParameter(UseInitalTime, bool);
90	>	DeclareParameter(UseIntialExtendedSystemState, bool);
91	>	DeclareParameter(OrthoBoxTolerance, RealType);
92	>	DeclareParameter(Minimizer, std::string);
93	>	DeclareParameter(MinimizerMaxIter, RealType);
94	>	DeclareParameter(MinimizerWriteFreq, int);
95	>	DeclareParameter(MinimizerStepSize, RealType);
96	>	DeclareParameter(MinimizerFTol, RealType);
97	>	DeclareParameter(MinimizerGTol, RealType);
98	>	DeclareParameter(MinimizerLSTol, RealType);
99	>	DeclareParameter(MinimizerLSMaxIter, int);
100	>	DeclareParameter(ZconsGap, RealType);
101	>	DeclareParameter(ZconsFixtime, RealType);
102	>	DeclareParameter(ZconsUsingSMD, bool);
103	>	DeclareParameter(UseThermodynamicIntegration, bool);
104	>	DeclareParameter(ThermodynamicIntegrationLambda, RealType);
105	>	DeclareParameter(ThermodynamicIntegrationK, RealType);
106	>	DeclareParameter(ForceFieldVariant, std::string);
107	>	DeclareParameter(ForceFieldFileName, std::string);
108	>	DeclareParameter(SurfaceTension, RealType);
109	>	DeclareParameter(PrintPressureTensor, bool);
110	>	DeclareParameter(PrintHeatFlux, bool);
111	>	DeclareParameter(TaggedAtomPair, intPair);
112	>	DeclareParameter(PrintTaggedPairDistance, bool);
113	>	DeclareParameter(ElectrostaticSummationMethod, std::string);
114	>	DeclareParameter(ElectrostaticScreeningMethod, std::string);
115	>	DeclareParameter(DampingAlpha, RealType);
116	>	DeclareParameter(Dielectric, RealType);
117	>	DeclareParameter(CutoffMethod, std::string);
118	>	DeclareParameter(CutoffPolicy, std::string);
119	>	DeclareParameter(SwitchingFunctionType, std::string);
120	>	DeclareParameter(CompressDumpFile, bool);
121	>	DeclareParameter(OutputForceVector, bool);
122	>	DeclareParameter(OutputParticlePotential, bool);
123	>	DeclareParameter(OutputElectricField, bool);
124	>	DeclareParameter(OutputFluctuatingCharges, bool);
125	>	DeclareParameter(SkinThickness, RealType);
126	>	DeclareParameter(StatFileFormat, std::string);
127	>	DeclareParameter(HydroPropFile, std::string);
128	>	DeclareParameter(Viscosity, RealType);
129	>	DeclareParameter(BeadSize, RealType);
130	>	DeclareParameter(UseSphericalBoundaryConditions, bool);
131	>	DeclareParameter(FrozenBufferRadius, RealType);
132	>	DeclareParameter(LangevinBufferRadius, RealType);
133	>	DeclareParameter(AccumulateBoxDipole, bool);
134	>	DeclareParameter(NeighborListNeighbors, int);
135	>	DeclareParameter(UseMultipleTemperatureMethod, bool);
136	>	DeclareParameter(MTM_Ce, RealType);
137	>	DeclareParameter(MTM_G, RealType);
138	>	DeclareParameter(MTM_Io, RealType);
139	>	DeclareParameter(MTM_Sigma, RealType);
140	>	DeclareParameter(MTM_R, RealType);
141	>	DeclareParameter(UseRNEMD, bool);
142	>	DeclareParameter(RNEMD_exchangeTime, RealType);
143	>	DeclareParameter(RNEMD_nBins, int);
144	>	DeclareParameter(RNEMD_logWidth, int);
145	>	DeclareParameter(RNEMD_exchangeType, std::string);
146	>	DeclareParameter(RNEMD_objectSelection, std::string);
147	>	DeclareParameter(RNEMD_targetFlux, RealType);
148	>	DeclareParameter(RNEMD_targetJzKE, RealType);
149	>	DeclareParameter(RNEMD_targetJzpx, RealType);
150	>	DeclareParameter(RNEMD_targetJzpy, RealType);
151	>	DeclareParameter(RNEMD_targetJzpz, RealType);
152	>	DeclareParameter(RNEMD_binShift, bool);
153	>	DeclareParameter(RNEMD_outputTemperature, bool);
154	>	DeclareParameter(RNEMD_outputVx, bool);
155	>	DeclareParameter(RNEMD_outputVy, bool);
156	>	// James put this in.
157	>	DeclareParameter(RNEMD_outputDen, bool);
158	>	DeclareParameter(RNEMD_outputVz, bool);
159	>	DeclareParameter(RNEMD_outputAh, bool);
160	>	DeclareParameter(RNEMD_outputXyzTemperature, bool);
161	>	DeclareParameter(RNEMD_outputRotTemperature, bool);
162	>	DeclareParameter(UseRestraints, bool);
163	>	DeclareParameter(Restraint_file, std::string);
164	>	DeclareParameter(HULL_Method, std::string);
165	>	DeclareParameter(Alpha, RealType);
166	>	DeclareParameter(FlucQPropagator, std::string);
167	>	DeclareParameter(FlucQFriction, RealType);
168	>	DeclareParameter(FlucQTolerance, RealType);
169	>	DeclareParameter(FlucQMaxIterations, int);
170	>	DeclareParameter(FlucQTargetTemp, RealType);
171	>	DeclareParameter(FlucQtauThermostat, RealType);
172	>	DeclareAlterableParameter(MDfileVersion, int);
173
174	<	void initalize();
175	<
176	<	int newComponent( event* the_event );
177	<	int componentAssign( event* the_event );
178	<	int componentEnd( event* the_event );
174	>	public:
175	>	bool addComponent(Component* comp);
176	>	bool addZConsStamp(ZConsStamp* zcons);
177	>	bool addRestraintStamp(RestraintStamp* rest);
178	>	bool addMoleculeStamp(MoleculeStamp* molStamp);
179	>	int getNComponents() {return components_.size();}
180	>	std::vector<Component*> getComponents() {return components_;}
181	>	Component* getComponentAt(int index) {return components_.at(index);}
182	>
183	>	int getNZconsStamps() {return zconstraints_.size();}
184	>	std::vector<ZConsStamp*> getZconsStamps() {return zconstraints_;}
185	>	ZConsStamp* getZconsStampAt(int index) {return zconstraints_.at(index);}
186
187	<	int newZconstraint( event* the_event );
188	<	int zConstraintAssign( event* the_event );
189	<	int zConstraintEnd( event* the_event );
190	<
191	<	int globalAssign( event* the_event );
192	<	int globalEnd( event* the_event );
193	<
194	<	char*  getForceField( void )      { return force_field; }
195	<	int    getNComponents( void )     { return n_components; }
196	<	double getTargetTemp( void )      { return target_temp; }
197	<	double getTargetPressure( void )  { return target_pressure; }
198	<	double getQmass( void )           { return q_mass; }
42	<	double getTauThermostat( void )   { return tau_thermostat; }
43	<	double getTauBarostat( void )     { return tau_barostat; }
44	<	char*  getEnsemble( void )        { return ensemble; }
45	<	double getDt( void )              { return dt; }
46	<	double getRunTime( void )         { return run_time; }
47	<
48	<	int    getNzConstraints( void )   { return n_zConstraints; }
49	<	char*  getInitialConfig( void )   { return initial_config; }
50	<	char*  getFinalConfig( void )     { return final_config; }
51	<	int    getNMol( void )            { return n_mol; }
52	<	double getDensity( void )         { return density; }
53	<	double getBox( void )             { return box; }
54	<	double getBoxX( void )            { return box_x; }
55	<	double getBoxY( void )            { return box_y; }
56	<	double getBoxZ( void )            { return box_z; }
57	<	double getSampleTime( void )      { return sample_time; }
58	<	double getStatusTime( void )      { return status_time; }
59	<	double getResetTime( void )       { return resetTime; }
60	<	double getThermalTime( void )     { return thermal_time; }
61	<	double getDielectric( void )      { return dielectric; }
62	<	double getRcut( void )            { return rcut; }
63	<	double getRsw( void )             { return rsw; }
64	<	int    getTempSet( void )         { return tempSet; }
65	<	int    getUseInitTime( void )     { return useInitTime; }
66	<	int    getUseInitXSstate( void )  { return useInitXSstate; }
67	<	double getOrthoBoxTolerance(void) { return orthoBoxTolerance; }
68	<	int    getPBC( void )             { return usePBC; }
69	<	int    getUseRF( void )           { return useRF; }
70	<	char*  getMixingRule( void)       { return mixingRule; }
71	<	double getZconsTime(void)         { return zcons_time; }
72	<	double getZconsTol(void)          { return zcons_tol; }
73	<	char*  getZconsForcePolicy(void)  { return zconsForcePolicy; }
74	<	double getZconsGap(void)          { return zcons_gap; }
75	<	double getZconsFixtime(void)      { return zcons_fixtime; }
76	<	int    getZconsUsingSMD(void)     { return zcons_using_smd; }
77	<	int    getSeed(void)              { return seed; }
78	<	char*  getMinimizer(void)         { return minimizer_name; }
79	<	int    getMinMaxIter(void)        { return minimizer_maxiteration; }
80	<	int    getMinWriteFrq(void)       { return minimizer_writefrq; }
81	<	double getMinStepSize(void)       { return minimizer_stepsize; }
82	<	double getMinFTol(void)           { return minimizer_ftol; }
83	<	double getMinGTol(void)           { return minimizer_gtol; }
84	<	double getMinLSTol(void)          { return minimizer_ls_tol; }
85	<	int    getMinLSMaxIter(void)      { return minimizer_ls_maxiteration; }
86	<	int    getUseSolidThermInt(void)  { return useSolidThermInt; }
87	<	int    getUseLiquidThermInt(void) { return useLiquidThermInt; }
88	<	double getThermIntLambda(void)    { return thermodynamic_integration_lambda; }
89	<	double getThermIntK(void)         { return thermodynamic_integration_k; }
90	<	char*  getForceFieldVariant( void ) { return forcefield_variant; }
91	<
92	<	short int haveDt( void )            { return have_dt; }
93	<	short int haveRunTime( void )       { return have_run_time; }
94	<	short int haveEnsemble( void )      { return have_ensemble; }
95	<	short int haveTargetTemp( void )    { return have_target_temp; }
96	<	short int haveInitialConfig( void ) { return have_initial_config; }
97	<	short int haveFinalConfig( void )   { return have_final_config; }
98	<	short int haveNMol( void )          { return have_n_mol; }
99	<	short int haveDensity( void )       { return have_density; }
100	<	short int haveBox( void )           { return have_box; }
101	<	short int haveBoxX( void )          { return have_box_x; }
102	<	short int haveBoxY( void )          { return have_box_y; }
103	<	short int haveBoxZ( void )          { return have_box_z; }
104	<	short int haveSampleTime( void )    { return have_sample_time; }
105	<	short int haveResetTime( void )     { return have_reset_time; }
106	<	short int haveStatusTime( void )    { return have_status_time; }
107	<	short int haveThermalTime( void )   { return have_thermal_time; }
108	<	short int haveRcut( void )          { return have_rcut; }
109	<	short int haveRsw( void )           { return have_rsw; }
110	<	short int haveDielectric( void )    { return have_dielectric; }
111	<	short int haveTempSet( void )       { return have_tempSet; }
112	<	short int haveTargetPressure( void ){ return have_target_pressure; }
113	<	short int haveQmass( void )         { return have_q_mass; }
114	<	short int haveTauThermostat( void ) { return have_tau_thermostat; }
115	<	short int haveTauBarostat( void )   { return have_tau_barostat; }
116	<	short int haveZconstraintTime(void) { return have_zcons_time; }
117	<	short int haveZconstraints( void )  { return have_zConstraints; }
118	<	short int haveZconsTol(void)        { return have_zcons_tol; }
119	<	short int haveZconsForcePolicy(void){ return have_zcons_force_policy; }
120	<	short int haveZConsGap(void)        { return have_zcons_gap; }
121	<	short int haveZConsFixTime(void)    { return have_zcons_fixtime; }
122	<	short int haveZConsUsingSMD(void)   { return have_zcons_using_smd; }
123	<	short int haveSeed(void)            { return have_seed; }
124	<	short int haveMinimizer(void)       { return have_minimizer; }
125	<	short int haveMinMaxIter(void)      { return have_minimizer_maxiteration; }
126	<	short int haveMinWriteFrq(void)     { return have_minimizer_writefrq; }
127	<	short int haveMinStepSize(void)     { return have_minimizer_stepsize; }
128	<	short int haveMinFTol(void)         { return have_minimizer_ftol; }
129	<	short int haveMinGTol(void)         { return have_minimizer_gtol; }
130	<	short int haveMinLSTol(void)        { return have_minimizer_ls_tol; }
131	<	short int haveMinLSMaxIter(void)    { return have_minimizer_ls_maxiteration;}
132	<	short int haveThermIntLambda(void)  { return have_thermodynamic_integration_lambda; }
133	<	short int haveThermIntK(void)       { return have_thermodynamic_integration_k; }
134	<	short int haveForceFieldVariant(void) { return have_forcefield_variant; }
135	<
136	<	/* other accessors */
137	<	Component** getComponents( void )   { return components; }
138	<	ZconStamp** getZconStamp( void )    { return zConstraints; }
139	<
140	<	private:
141	<
142	<	int hash_size;
143	<	int hash_shift;
144	<	int hash( char* text );
145	<	void addHash( char* text, int token );
146	<	LinkedCommand** command_table;
147	<
148	<	char* checkMe( void );
149	<
150	<	Component* current_component;
151	<	Component** components; // the array of components
152	<
153	<	ZconStamp* current_zConstraint;
154	<	ZconStamp** zConstraints; // the array of zConstraints
155	<
156	<	char force_field[100];
157	<	int n_components;
158	<	int n_zConstraints;
159	<	double target_temp;
160	<	double target_pressure;
161	<	char ensemble[100];
162	<	char mixingRule[100];
163	<	double dt;
164	<	double run_time;
165	<	char initial_config[120];
166	<	char final_config[120];
167	<	int n_mol;
168	<	double density;
169	<	double box;
170	<	double box_x, box_y, box_z;
171	<	double sample_time;
172	<	double status_time;
173	<	double resetTime;
174	<	double orthoBoxTolerance;
175	<	double thermal_time;
176	<	double rcut;
177	<	double rsw;
178	<	double dielectric;
179	<	int tempSet;
180	<	int useInitTime;
181	<	int useInitXSstate;
182	<	int usePBC;
183	<	int useRF;
184	<	double q_mass;
185	<	double tau_thermostat;
186	<	double tau_barostat;
187	<	double zcons_time;
188	<	double zcons_tol;
189	<	char zconsForcePolicy[100];
190	<	double zcons_gap;
191	<	double zcons_fixtime;
192	<	int zcons_using_smd;
193	<
194	<	int seed;
195	<	char minimizer_name[100];
196	<	int minimizer_maxiteration;
197	<	int minimizer_writefrq;
198	<	double minimizer_stepsize;
199	<	double minimizer_ftol;
200	<	double minimizer_gtol;
201	<	double minimizer_ls_tol;
202	<	int minimizer_ls_maxiteration;
203	<	int useSolidThermInt;
204	<	int useLiquidThermInt;
205	<	double thermodynamic_integration_lambda;
206	<	double thermodynamic_integration_k;
207	<	char forcefield_variant[100];
208	<
209	<	//required arguments
210	<	short int have_force_field, have_n_components, have_target_temp;
211	<	short int have_target_pressure, have_ensemble, have_dt, have_run_time;
212	<
213	<	// optional arguments
214	<	short int have_initial_config, have_final_config, have_n_mol;
215	<	short int have_density, have_box, have_box_x, have_box_y, have_box_z;
216	<	short int have_sample_time, have_status_time, have_rcut, have_dielectric;
217	<	short int have_tempSet, have_thermal_time, have_rsw, have_q_mass;
218	<	short int have_tau_thermostat, have_tau_barostat;
219	<	short int have_zcons_time, have_zConstraints, have_n_zConstraints;
220	<	short int have_zcons_tol, have_seed;
221	<	short int have_zcons_force_policy, have_reset_time;
222	<	short int have_zcons_gap, have_zcons_fixtime;
223	<	short int have_zcons_using_smd;
224	<	short int have_minimizer, have_minimizer_maxiteration;
225	<	short int have_minimizer_writefrq, have_minimizer_stepsize;
226	<	short int have_minimizer_ftol, have_minimizer_gtol;
227	<	short int have_minimizer_ls_tol, have_minimizer_ls_maxiteration;
228	<	short int have_thermodynamic_integration_lambda;
229	<	short int have_thermodynamic_integration_k;
230	<	short int have_forcefield_variant;
187	>	int getNRestraintStamps() {return restraints_.size();}
188	>	std::vector<RestraintStamp*> getRestraintStamps() {return restraints_;}
189	>	RestraintStamp* getRestraintStampAt(int index) {return restraints_.at(index);}
190	>
191	>	virtual void validate();
192	>	private:
193	>
194	>	std::vector<Component*> components_;
195	>	std::vector<ZConsStamp*> zconstraints_;
196	>	std::vector<RestraintStamp*> restraints_;
197	>	std::map<std::string, MoleculeStamp*> moleculeStamps_;
198	>	std::pair<int, int> taggedAtomPair_;
199		};
200	<
200	>	}
201		#endif

Comparing:
trunk/src/io/Globals.hpp (property svn:keywords), Revision 3 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
branches/development/src/io/Globals.hpp (property svn:keywords), Revision 1729 by jmarr, Wed May 30 16:08:07 2012 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

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