OOPSE/libmdtools/Integrator.hpp

#ifndef _INTEGRATOR_H_
#define _INTEGRATOR_H_

#include "Atom.hpp"
#include "Molecule.hpp"
#include "SRI.hpp"
#include "AbstractClasses.hpp"
#include "SimInfo.hpp"
#include "ForceFields.hpp"
#include "Thermo.hpp"
#include "ReadWrite.hpp"

const double kB = 8.31451e-7;// boltzmann constant amu*Ang^2*fs^-2/K
const double eConvert = 4.184e-4; // converts kcal/mol -> amu*A^2/fs^2
const double p_convert = 1.63882576e8; //converts amu*fs^-2*Ang^-1 -> atm
const int maxIteration = 300;
const double tol = 1.0e-6;

class Integrator : public BaseIntegrator {

public:
  Integrator( SimInfo *theInfo, ForceFields* the_ff );
  virtual ~Integrator();
  void integrate( void );


protected:
  
  virtual void integrateStep( int calcPot, int calcStress );
  virtual void preMove( void );
  virtual void moveA( void );
  virtual void moveB( void );
  virtual void constrainA( void );
  virtual void constrainB( void );
  virtual int  readyCheck( void ) { return 1; }
  
  void checkConstraints( void );
  void rotate( int axes1, int axes2, double angle, double j[3], 
               double A[3][3] );


  ForceFields* myFF;

  SimInfo *info; // all the info we'll ever need
  int nAtoms;  /* the number of atoms */
  int oldAtoms;
  Atom **atoms; /* array of atom pointers */
  Molecule* molecules;
  int nMols;

  int isConstrained; // boolean to know whether the systems contains
                     // constraints.
  int nConstrained;  // counter for number of constraints 
  int *constrainedA; // the i of a constraint pair 
  int *constrainedB; // the j of a constraint pair 
  double *constrainedDsqr; // the square of the constraint distance 
  
  int* moving; // tells whether we are moving atom i
  int* moved;  // tells whether we have moved atom i
  double* oldPos; // pre constrained positions 

  short isFirst; /*boolean for the first time integrate is called */
  
  double dt;
  double dt2;

  Thermo *tStats;
  StatWriter*  statOut;
  DumpWriter*  dumpOut;
  
};

class NVE : public Integrator{

public:
  NVE ( SimInfo *theInfo, ForceFields* the_ff ):
    Integrator( theInfo, the_ff ){}
  virtual ~NVE(){}

  
};

class NVT : public Integrator{

public:

  NVT ( SimInfo *theInfo, ForceFields* the_ff);
  virtual ~NVT() {}

  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}

protected:

  virtual void moveA( void );
  virtual void moveB( void );

  virtual int readyCheck();

  // chi is a propagated degree of freedom.

  double chi;

  // targetTemp must be set.  tauThermostat must also be set;

  double targetTemp;
  double tauThermostat;
  
  short int have_tau_thermostat, have_target_temp;

};


class NPTi : public Integrator{

public:

  NPTi ( SimInfo *theInfo, ForceFields* the_ff);
  virtual ~NPTi() {};

  virtual void integrateStep( int calcPot, int calcStress ){
    calcStress = 1;
    Integrator::integrateStep( calcPot, calcStress );
  }

  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}

protected:

  virtual void  moveA( void );
  virtual void moveB( void );

  virtual int readyCheck();

  // chi and eta are the propagated degrees of freedom

  double chi;
  double eta;
  double NkBT;

  // targetTemp, targetPressure, and tauBarostat must be set.  
  // One of qmass or tauThermostat must be set;

  double targetTemp;
  double targetPressure;
  double tauThermostat;
  double tauBarostat;

  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
  short int have_target_pressure;

};

class NPTim : public Integrator{

public:

  NPTim ( SimInfo *theInfo, ForceFields* the_ff);
  virtual ~NPTim() {};

  virtual void integrateStep( int calcPot, int calcStress ){
    calcStress = 1;
    Integrator::integrateStep( calcPot, calcStress );
  }

  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}

protected:

  virtual void moveA( void );
  virtual void moveB( void );

  virtual int readyCheck();

  Molecule* myMolecules;
  Atom** myAtoms;

  // chi and eta are the propagated degrees of freedom

  double chi;
  double eta;
  double NkBT;

  // targetTemp, targetPressure, and tauBarostat must be set.  
  // One of qmass or tauThermostat must be set;

  double targetTemp;
  double targetPressure;
  double tauThermostat;
  double tauBarostat;

  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
  short int have_target_pressure;

};

class NPTf : public Integrator{

public:

  NPTf ( SimInfo *theInfo, ForceFields* the_ff);
  virtual ~NPTf() {};

  virtual void integrateStep( int calcPot, int calcStress ){
    calcStress = 1;
    Integrator::integrateStep( calcPot, calcStress );
  }

  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}

protected:

  virtual void  moveA( void );
  virtual void moveB( void );

  virtual int readyCheck();

  // chi and eta are the propagated degrees of freedom

  double chi;
  double eta[3][3];
  double NkBT;

  // targetTemp, targetPressure, and tauBarostat must be set.  
  // One of qmass or tauThermostat must be set;

  double targetTemp;
  double targetPressure;
  double tauThermostat;
  double tauBarostat;

  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
  short int have_target_pressure;

};

class NPTfm : public Integrator{

public:

  NPTfm ( SimInfo *theInfo, ForceFields* the_ff);
  virtual ~NPTfm() {};

  virtual void integrateStep( int calcPot, int calcStress ){
    calcStress = 1;
    Integrator::integrateStep( calcPot, calcStress );
  }

  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}

protected:

  virtual void  moveA( void );
  virtual void moveB( void );

  virtual int readyCheck();

  // chi and eta are the propagated degrees of freedom

  double chi;
  double eta[3][3];
  double NkBT;

  // targetTemp, targetPressure, and tauBarostat must be set.  
  // One of qmass or tauThermostat must be set;

  double targetTemp;
  double targetPressure;
  double tauThermostat;
  double tauBarostat;

  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
  short int have_target_pressure;

};

#endif
Revision:	604
Committed:	Tue Jul 15 03:08:00 2003 UTC (20 years, 11 months ago) by gezelter
File size:	7105 byte(s)
Log Message:	Checking in changes for NPTim
#	Content
1	#ifndef _INTEGRATOR_H_
2	#define _INTEGRATOR_H_
3
4	#include "Atom.hpp"
5	#include "Molecule.hpp"
6	#include "SRI.hpp"
7	#include "AbstractClasses.hpp"
8	#include "SimInfo.hpp"
9	#include "ForceFields.hpp"
10	#include "Thermo.hpp"
11	#include "ReadWrite.hpp"
12
13	const double kB = 8.31451e-7;// boltzmann constant amuAng^2fs^-2/K
14	const double eConvert = 4.184e-4; // converts kcal/mol -> amu*A^2/fs^2
15	const double p_convert = 1.63882576e8; //converts amufs^-2Ang^-1 -> atm
16	const int maxIteration = 300;
17	const double tol = 1.0e-6;
18
19	class Integrator : public BaseIntegrator {
20
21	public:
22	Integrator( SimInfo theInfo, ForceFields the_ff );
23	virtual ~Integrator();
24	void integrate( void );
25
26
27	protected:
28
29	virtual void integrateStep( int calcPot, int calcStress );
30	virtual void preMove( void );
31	virtual void moveA( void );
32	virtual void moveB( void );
33	virtual void constrainA( void );
34	virtual void constrainB( void );
35	virtual int readyCheck( void ) { return 1; }
36
37	void checkConstraints( void );
38	void rotate( int axes1, int axes2, double angle, double j[3],
39	double A[3][3] );
40
41
42	ForceFields* myFF;
43
44	SimInfo *info; // all the info we'll ever need
45	int nAtoms; /* the number of atoms */
46	int oldAtoms;
47	Atom *atoms; / array of atom pointers */
48	Molecule* molecules;
49	int nMols;
50
51	int isConstrained; // boolean to know whether the systems contains
52	// constraints.
53	int nConstrained; // counter for number of constraints
54	int *constrainedA; // the i of a constraint pair
55	int *constrainedB; // the j of a constraint pair
56	double *constrainedDsqr; // the square of the constraint distance
57
58	int* moving; // tells whether we are moving atom i
59	int* moved; // tells whether we have moved atom i
60	double* oldPos; // pre constrained positions
61
62	short isFirst; /boolean for the first time integrate is called /
63
64	double dt;
65	double dt2;
66
67	Thermo *tStats;
68	StatWriter* statOut;
69	DumpWriter* dumpOut;
70
71	};
72
73	class NVE : public Integrator{
74
75	public:
76	NVE ( SimInfo theInfo, ForceFields the_ff ):
77	Integrator( theInfo, the_ff ){}
78	virtual ~NVE(){}
79
80
81
82	};
83
84	class NVT : public Integrator{
85
86	public:
87
88	NVT ( SimInfo theInfo, ForceFields the_ff);
89	virtual ~NVT() {}
90
91	void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
92	void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
93
94	protected:
95
96	virtual void moveA( void );
97	virtual void moveB( void );
98
99	virtual int readyCheck();
100
101	// chi is a propagated degree of freedom.
102
103	double chi;
104
105	// targetTemp must be set. tauThermostat must also be set;
106
107	double targetTemp;
108	double tauThermostat;
109
110	short int have_tau_thermostat, have_target_temp;
111
112	};
113
114
115	class NPTi : public Integrator{
116
117	public:
118
119	NPTi ( SimInfo theInfo, ForceFields the_ff);
120	virtual ~NPTi() {};
121
122	virtual void integrateStep( int calcPot, int calcStress ){
123	calcStress = 1;
124	Integrator::integrateStep( calcPot, calcStress );
125	}
126
127	void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
128	void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
129	void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
130	void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
131
132	protected:
133
134	virtual void moveA( void );
135	virtual void moveB( void );
136
137	virtual int readyCheck();
138
139	// chi and eta are the propagated degrees of freedom
140
141	double chi;
142	double eta;
143	double NkBT;
144
145	// targetTemp, targetPressure, and tauBarostat must be set.
146	// One of qmass or tauThermostat must be set;
147
148	double targetTemp;
149	double targetPressure;
150	double tauThermostat;
151	double tauBarostat;
152
153	short int have_tau_thermostat, have_tau_barostat, have_target_temp;
154	short int have_target_pressure;
155
156	};
157
158	class NPTim : public Integrator{
159
160	public:
161
162	NPTim ( SimInfo theInfo, ForceFields the_ff);
163	virtual ~NPTim() {};
164
165	virtual void integrateStep( int calcPot, int calcStress ){
166	calcStress = 1;
167	Integrator::integrateStep( calcPot, calcStress );
168	}
169
170	void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
171	void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
172	void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
173	void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
174
175	protected:
176
177	virtual void moveA( void );
178	virtual void moveB( void );
179
180	virtual int readyCheck();
181
182	Molecule* myMolecules;
183	Atom** myAtoms;
184
185	// chi and eta are the propagated degrees of freedom
186
187	double chi;
188	double eta;
189	double NkBT;
190
191	// targetTemp, targetPressure, and tauBarostat must be set.
192	// One of qmass or tauThermostat must be set;
193
194	double targetTemp;
195	double targetPressure;
196	double tauThermostat;
197	double tauBarostat;
198
199	short int have_tau_thermostat, have_tau_barostat, have_target_temp;
200	short int have_target_pressure;
201
202	};
203
204	class NPTf : public Integrator{
205
206	public:
207
208	NPTf ( SimInfo theInfo, ForceFields the_ff);
209	virtual ~NPTf() {};
210
211	virtual void integrateStep( int calcPot, int calcStress ){
212	calcStress = 1;
213	Integrator::integrateStep( calcPot, calcStress );
214	}
215
216	void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
217	void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
218	void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
219	void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
220
221	protected:
222
223	virtual void moveA( void );
224	virtual void moveB( void );
225
226	virtual int readyCheck();
227
228	// chi and eta are the propagated degrees of freedom
229
230	double chi;
231	double eta[3][3];
232	double NkBT;
233
234	// targetTemp, targetPressure, and tauBarostat must be set.
235	// One of qmass or tauThermostat must be set;
236
237	double targetTemp;
238	double targetPressure;
239	double tauThermostat;
240	double tauBarostat;
241
242	short int have_tau_thermostat, have_tau_barostat, have_target_temp;
243	short int have_target_pressure;
244
245	};
246
247	class NPTfm : public Integrator{
248
249	public:
250
251	NPTfm ( SimInfo theInfo, ForceFields the_ff);
252	virtual ~NPTfm() {};
253
254	virtual void integrateStep( int calcPot, int calcStress ){
255	calcStress = 1;
256	Integrator::integrateStep( calcPot, calcStress );
257	}
258
259	void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
260	void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
261	void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
262	void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
263
264	protected:
265
266	virtual void moveA( void );
267	virtual void moveB( void );
268
269	virtual int readyCheck();
270
271	// chi and eta are the propagated degrees of freedom
272
273	double chi;
274	double eta[3][3];
275	double NkBT;
276
277	// targetTemp, targetPressure, and tauBarostat must be set.
278	// One of qmass or tauThermostat must be set;
279
280	double targetTemp;
281	double targetPressure;
282	double tauThermostat;
283	double tauBarostat;
284
285	short int have_tau_thermostat, have_tau_barostat, have_target_temp;
286	short int have_target_pressure;
287
288	};
289
290	#endif