OOPSE/libmdtools/SimInfo.hpp

#ifndef __SIMINFO_H__
#define __SIMINFO_H__

#include <map>
#include <string>
#include <vector>

#include "Atom.hpp"
#include "RigidBody.hpp"
#include "Molecule.hpp"
#include "Exclude.hpp"
#include "SkipList.hpp"
#include "AbstractClasses.hpp"
#include "MakeStamps.hpp"
#include "SimState.hpp"
#include "Restraints.hpp"

#define __C
#include "fSimulation.h"
#include "fortranWrapDefines.hpp"
#include "GenericData.hpp"
//#include "Minimizer.hpp"
//#include "OOPSEMinimizer.hpp"


double roundMe( double x );
class OOPSEMinimizer;
class SimInfo{

public:

  SimInfo();
  ~SimInfo();

  int n_atoms; // the number of atoms
  Atom **atoms; // the array of atom objects

  vector<RigidBody*> rigidBodies;  // A vector of rigid bodies
  vector<StuntDouble*> integrableObjects;
  
  double tau[9]; // the stress tensor

  int n_bonds;    // number of bends
  int n_bends;    // number of bends
  int n_torsions; // number of torsions
  int n_oriented; // number of of atoms with orientation
  int ndf;        // number of actual degrees of freedom
  int ndfRaw;     // number of settable degrees of freedom
  int ndfTrans;   // number of translational degrees of freedom
  int nZconstraints; // the number of zConstraints

  int setTemp;   // boolean to set the temperature at each sampleTime
  int resetIntegrator; // boolean to reset the integrator

  int n_dipoles; // number of dipoles

  int n_exclude;
  Exclude* excludes;  // the exclude list for ignoring pairs in fortran
  int nGlobalExcludes;
  int* globalExcludes; // same as above, but these guys participate in
                       // no long range forces.

  int* identArray;     // array of unique identifiers for the atoms
  int* molMembershipArray;  // map of atom numbers onto molecule numbers

  int n_constraints; // the number of constraints on the system

  int n_SRI;   // the number of short range interactions

  double lrPot; // the potential energy from the long range calculations.

  double Hmat[3][3];  // the periodic boundry conditions. The Hmat is the
                      // column vectors of the x, y, and z box vectors.
                      //   h1  h2  h3
                      // [ Xx  Yx  Zx ]
                      // [ Xy  Yy  Zy ]
                      // [ Xz  Yz  Zz ]
                      //   
  double HmatInv[3][3];

  double boxL[3]; // The Lengths of the 3 column vectors of Hmat
  double boxVol;
  int orthoRhombic;
  

  double dielectric;      // the dielectric of the medium for reaction field

  
  int usePBC; // whether we use periodic boundry conditions.
  int useLJ; 
  int useSticky;
  int useCharges;
  int useDipoles;
  int useReactionField;
  int useGB;
  int useEAM;
  bool haveCutoffGroups;
  bool useInitXSstate;
  double orthoTolerance;

  double dt, run_time;           // the time step and total time
  double sampleTime, statusTime; // the position and energy dump frequencies
  double target_temp;            // the target temperature of the system
  double thermalTime;            // the temp kick interval
  double currentTime;            // Used primarily for correlation Functions
  double resetTime;              // Use to reset the integrator periodically

  int n_mol;           // n_molecules;
  Molecule* molecules; // the array of molecules
  
  int nComponents;           // the number of components in the system
  int* componentsNmol;       // the number of molecules of each component
  MoleculeStamp** compStamps;// the stamps matching the components
  LinkedMolStamp* headStamp; // list of stamps used in the simulation
  
  
  char ensemble[100]; // the enesemble of the simulation (NVT, NVE, etc. )
  char mixingRule[100]; // the mixing rules for Lennard jones/van der walls 
  BaseIntegrator *the_integrator; // the integrator of the simulation

  OOPSEMinimizer* the_minimizer; // the energy minimizer
  Restraints* restraint;
  bool has_minimizer;

  char finalName[300];  // the name of the eor file to be written
  char sampleName[300]; // the name of the dump file to be written
  char statusName[300]; // the name of the stat file to be written
  char rawPotName[300];  // the name of the raw file to be written

  int seed;                    //seed for random number generator

  bool useThermInt;
  double thermIntLambda;
  double thermIntK;

  double vRaw;
  double vHarm;


  vector<double> mfact;
  int ngroup;
  vector<int> groupList;
  vector<int> groupStart;
  
  // refreshes the sim if things get changed (load balanceing, volume
  // adjustment, etc.)

  void refreshSim( void );
  

  // sets the internal function pointer to fortran.

  void setInternal( setFortranSim_TD fSetup,
                    setFortranBox_TD fBox,
                    notifyFortranCutOff_TD fCut){
    setFsimulation = fSetup;
    setFortranBoxSize = fBox;
    notifyFortranCutOffs = fCut;
  }

  int getNDF();
  int getNDFraw();
  int getNDFtranslational();
  int getTotIntegrableObjects();
  void setBox( double newBox[3] );
  void setBoxM( double newBox[3][3] );
  void getBoxM( double theBox[3][3] );
  void scaleBox( double scale );
  
  void setDefaultRcut( double theRcut );
  void setDefaultRcut( double theRcut, double theRsw );
  void checkCutOffs( void );

  double getRcut( void )  { return rCut; }
  double getRlist( void ) { return rList; }
  double getRsw( void )   { return rSw; }
  double getMaxCutoff( void ) { return maxCutoff; }
  
  void setTime( double theTime ) { currentTime = theTime; }
  void incrTime( double the_dt ) { currentTime += the_dt; }
  void decrTime( double the_dt ) { currentTime -= the_dt; }
  double getTime( void ) { return currentTime; }

  void wrapVector( double thePos[3] );

  SimState* getConfiguration( void ) { return myConfiguration; }
  
  void addProperty(GenericData* prop); 
  GenericData* getProperty(const string& propName);
  //vector<GenericData*>& getProperties()  {return properties;}     

  int getSeed(void) {  return seed; }
  void setSeed(int theSeed) {  seed = theSeed;}

private:

  SimState* myConfiguration;

  int boxIsInit, haveRcut, haveRsw;

  double rList, rCut; // variables for the neighborlist
  double rSw;         // the switching radius

  double maxCutoff;

  double distXY;
  double distYZ;
  double distZX;
  
  void calcHmatInv( void );
  void calcBoxL();
  double calcMaxCutOff();

  // private function to initialize the fortran side of the simulation
  setFortranSim_TD setFsimulation;

  setFortranBox_TD setFortranBoxSize;
  
  notifyFortranCutOff_TD notifyFortranCutOffs;
  
  //Addtional Properties of SimInfo
  map<string, GenericData*> properties;

};

void getFortranGroupArray(SimInfo* info, vector<double>& mfact, int& ngroup,
                                                          vector<int>& groupList, vector<int>& groupStart);

#endif
Revision:	1180
Committed:	Thu May 20 20:24:07 2004 UTC (21 years, 5 months ago) by chrisfen
File size:	6732 byte(s)
Log Message:	Several additions... Restraints.cpp and .hpp were included for restraining particles in thermodynamic integration. By including these, changes were made in Integrator, SimInfo, ForceFeilds, SimSetup, StatWriter, and possibly some other files. Two bass keywords were also added for performing thermodynamic integration: a lambda value one and a k power one.
#	User	Rev	Content
1	mmeineke	377	#ifndef __SIMINFO_H__
2			#define __SIMINFO_H__
3
4	tim	658	#include <map>
5			#include <string>
6			#include <vector>
7	mmeineke	377
8			#include "Atom.hpp"
9	gezelter	1097	#include "RigidBody.hpp"
10	mmeineke	377	#include "Molecule.hpp"
11	gezelter	1097	#include "Exclude.hpp"
12			#include "SkipList.hpp"
13	mmeineke	377	#include "AbstractClasses.hpp"
14			#include "MakeStamps.hpp"
15	mmeineke	670	#include "SimState.hpp"
16	chrisfen	1180	#include "Restraints.hpp"
17	mmeineke	377
18			#define __C
19			#include "fSimulation.h"
20			#include "fortranWrapDefines.hpp"
21	tim	658	#include "GenericData.hpp"
22	tim	1064	//#include "Minimizer.hpp"
23			//#include "OOPSEMinimizer.hpp"
24	chrisfen	1180
25
26	tim	1131	double roundMe( double x );
27	tim	1064	class OOPSEMinimizer;
28	mmeineke	377	class SimInfo{
29
30			public:
31
32			SimInfo();
33	tim	660	~SimInfo();
34	mmeineke	377
35			int n_atoms; // the number of atoms
36			Atom **atoms; // the array of atom objects
37	gezelter	1097
38			vector<RigidBody*> rigidBodies; // A vector of rigid bodies
39			vector<StuntDouble*> integrableObjects;
40	mmeineke	377
41			double tau[9]; // the stress tensor
42
43	mmeineke	787	int n_bonds; // number of bends
44			int n_bends; // number of bends
45			int n_torsions; // number of torsions
46			int n_oriented; // number of of atoms with orientation
47			int ndf; // number of actual degrees of freedom
48			int ndfRaw; // number of settable degrees of freedom
49			int ndfTrans; // number of translational degrees of freedom
50			int nZconstraints; // the number of zConstraints
51	mmeineke	377
52	mmeineke	787	int setTemp; // boolean to set the temperature at each sampleTime
53			int resetIntegrator; // boolean to reset the integrator
54	mmeineke	377
55	mmeineke	787	int n_dipoles; // number of dipoles
56	mmeineke	377
57	gezelter	1097	int n_exclude;
58			Exclude* excludes; // the exclude list for ignoring pairs in fortran
59	mmeineke	377	int nGlobalExcludes;
60			int* globalExcludes; // same as above, but these guys participate in
61			// no long range forces.
62
63			int* identArray; // array of unique identifiers for the atoms
64	gezelter	483	int* molMembershipArray; // map of atom numbers onto molecule numbers
65	mmeineke	377
66			int n_constraints; // the number of constraints on the system
67
68	mmeineke	787	int n_SRI; // the number of short range interactions
69	mmeineke	377
70			double lrPot; // the potential energy from the long range calculations.
71
72	gezelter	588	double Hmat[3][3]; // the periodic boundry conditions. The Hmat is the
73			// column vectors of the x, y, and z box vectors.
74			// h1 h2 h3
75			// [ Xx Yx Zx ]
76			// [ Xy Yy Zy ]
77			// [ Xz Yz Zz ]
78			//
79			double HmatInv[3][3];
80	mmeineke	568
81	gezelter	621	double boxL[3]; // The Lengths of the 3 column vectors of Hmat
82	mmeineke	572	double boxVol;
83			int orthoRhombic;
84	mmeineke	568
85
86	mmeineke	626	double dielectric; // the dielectric of the medium for reaction field
87	mmeineke	568
88	mmeineke	377
89			int usePBC; // whether we use periodic boundry conditions.
90			int useLJ;
91			int useSticky;
92	gezelter	941	int useCharges;
93			int useDipoles;
94	mmeineke	377	int useReactionField;
95			int useGB;
96			int useEAM;
97	tim	1157	bool haveCutoffGroups;
98	mmeineke	855	bool useInitXSstate;
99			double orthoTolerance;
100	mmeineke	377
101			double dt, run_time; // the time step and total time
102			double sampleTime, statusTime; // the position and energy dump frequencies
103			double target_temp; // the target temperature of the system
104			double thermalTime; // the temp kick interval
105	gezelter	637	double currentTime; // Used primarily for correlation Functions
106	mmeineke	746	double resetTime; // Use to reset the integrator periodically
107	mmeineke	377
108			int n_mol; // n_molecules;
109			Molecule* molecules; // the array of molecules
110
111	mmeineke	823	int nComponents; // the number of components in the system
112	mmeineke	377	int* componentsNmol; // the number of molecules of each component
113			MoleculeStamp** compStamps;// the stamps matching the components
114			LinkedMolStamp* headStamp; // list of stamps used in the simulation
115
116
117			char ensemble[100]; // the enesemble of the simulation (NVT, NVE, etc. )
118			char mixingRule[100]; // the mixing rules for Lennard jones/van der walls
119	mmeineke	542	BaseIntegrator *the_integrator; // the integrator of the simulation
120	mmeineke	377
121	tim	1064	OOPSEMinimizer* the_minimizer; // the energy minimizer
122	chrisfen	1180	Restraints* restraint;
123	tim	1031	bool has_minimizer;
124
125	mmeineke	377	char finalName[300]; // the name of the eor file to be written
126			char sampleName[300]; // the name of the dump file to be written
127			char statusName[300]; // the name of the stat file to be written
128	chrisfen	1180	char rawPotName[300]; // the name of the raw file to be written
129	mmeineke	377
130	tim	708	int seed; //seed for random number generator
131	tim	1144
132	chrisfen	1180	bool useThermInt;
133			double thermIntLambda;
134			double thermIntK;
135	tim	1144
136	chrisfen	1180	double vRaw;
137			double vHarm;
138
139
140	tim	1144	vector<double> mfact;
141			int ngroup;
142			vector<int> groupList;
143			vector<int> groupStart;
144
145	mmeineke	377	// refreshes the sim if things get changed (load balanceing, volume
146			// adjustment, etc.)
147
148			void refreshSim( void );
149
150
151			// sets the internal function pointer to fortran.
152
153	mmeineke	836	void setInternal( setFortranSim_TD fSetup,
154			setFortranBox_TD fBox,
155			notifyFortranCutOff_TD fCut){
156	mmeineke	377	setFsimulation = fSetup;
157			setFortranBoxSize = fBox;
158	mmeineke	626	notifyFortranCutOffs = fCut;
159	mmeineke	377	}
160
161	gezelter	458	int getNDF();
162			int getNDFraw();
163	tim	767	int getNDFtranslational();
164	tim	1108	int getTotIntegrableObjects();
165	gezelter	457	void setBox( double newBox[3] );
166	gezelter	588	void setBoxM( double newBox[3][3] );
167			void getBoxM( double theBox[3][3] );
168	gezelter	574	void scaleBox( double scale );
169	mmeineke	626
170	mmeineke	841	void setDefaultRcut( double theRcut );
171	gezelter	1154	void setDefaultRcut( double theRcut, double theRsw );
172	gezelter	845	void checkCutOffs( void );
173	gezelter	457
174	mmeineke	626	double getRcut( void ) { return rCut; }
175			double getRlist( void ) { return rList; }
176	gezelter	1154	double getRsw( void ) { return rSw; }
177	mmeineke	797	double getMaxCutoff( void ) { return maxCutoff; }
178	gezelter	1154
179	mmeineke	644	void setTime( double theTime ) { currentTime = theTime; }
180	mmeineke	790	void incrTime( double the_dt ) { currentTime += the_dt; }
181			void decrTime( double the_dt ) { currentTime -= the_dt; }
182	mmeineke	644	double getTime( void ) { return currentTime; }
183	mmeineke	626
184	mmeineke	568	void wrapVector( double thePos[3] );
185
186	mmeineke	670	SimState* getConfiguration( void ) { return myConfiguration; }
187	gezelter	588
188	tim	658	void addProperty(GenericData* prop);
189			GenericData* getProperty(const string& propName);
190	tim	1118	//vector<GenericData*>& getProperties() {return properties;}
191	mmeineke	670
192	tim	708	int getSeed(void) { return seed; }
193			void setSeed(int theSeed) { seed = theSeed;}
194
195	mmeineke	377	private:
196	mmeineke	626
197	mmeineke	670	SimState* myConfiguration;
198
199	gezelter	1154	int boxIsInit, haveRcut, haveRsw;
200	mmeineke	626
201			double rList, rCut; // variables for the neighborlist
202	gezelter	1154	double rSw; // the switching radius
203
204	mmeineke	626	double maxCutoff;
205	tim	781
206			double distXY;
207			double distYZ;
208			double distZX;
209	mmeineke	377
210	gezelter	588	void calcHmatInv( void );
211	mmeineke	568	void calcBoxL();
212	tim	781	double calcMaxCutOff();
213	mmeineke	568
214	mmeineke	377	// private function to initialize the fortran side of the simulation
215	mmeineke	836	setFortranSim_TD setFsimulation;
216	mmeineke	377
217	mmeineke	836	setFortranBox_TD setFortranBoxSize;
218	mmeineke	626
219	mmeineke	836	notifyFortranCutOff_TD notifyFortranCutOffs;
220	tim	658
221			//Addtional Properties of SimInfo
222			map<string, GenericData*> properties;
223	mmeineke	626
224	mmeineke	377	};
225
226	tim	1144	void getFortranGroupArray(SimInfo* info, vector<double>& mfact, int& ngroup,
227			vector<int>& groupList, vector<int>& groupStart);
228
229	mmeineke	377	#endif