OOPSE/libmdtools/ForceFields.hpp

#ifndef __FORCEFIELDS_H__
#define __FORCEFIELDS_H__

#define MK_STR(s) # s
#define STR_DEFINE(t, s) t = MK_STR(s)


#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "Atom.hpp"
#include "SimInfo.hpp"
#include "StuntDouble.hpp"

#ifdef IS_MPI
#include "mpiForceField.h"
#endif

#include "fForceField.h"
#include "fortranWrapDefines.hpp"

class bond_pair{
public:
  bond_pair(){}
  ~bond_pair(){}

  int a;
  int b;
};

class bend_set{
public:
  bend_set(){ isGhost = 0; }
  ~bend_set(){}

  int ghost;
  int isGhost;

  int a;
  int b;
  int c;
};

class torsion_set{
public:
  torsion_set(){}
  ~torsion_set(){}

  int a;
  int b;
  int c;
  int d;
};


class ForceFields{

public:
  ForceFields(){ frcFile = NULL; entry_plug = NULL; }
  virtual ~ForceFields(){}
  
  void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
  
  virtual void readParams( void ) = 0;
  virtual void cleanMe( void ) = 0;
  

  virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
  virtual void initializeBonds( int nBonds, Bond** bondArray,
                                bond_pair* the_bonds ) = 0;
  virtual void initializeBends( int nBends, Bend** bendArray,
                                bend_set* the_bends ) = 0;
  virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
                                   torsion_set* the_torsions ) = 0;
  virtual void initForceField( int ljMixRule ) = 0;
  virtual void initRestraints();
  virtual void dumpzAngle();

  virtual void calcRcut( void );
  virtual void setRcut( double LJrcut );
  virtual void doForces( int calcPot, int calcStress );

  void setFortranForceLoop( doForceLoop_TD fsub ){
    fortranForceLoop = fsub;
  }

protected:
  
  void initFortran( int ljMixPolicy, int useReactionField );
  doForceLoop_TD fortranForceLoop;

  FILE *frcFile;
  SimInfo* entry_plug;
  
  int lineNum;
  char readLine[500];
  char* eof_test;
  double bigSigma;

  vector<StuntDouble*> myStunts;

};


class DUFF : public ForceFields{

public:
  DUFF();
  virtual ~DUFF();

  void readParams();
  void cleanMe( void );

  void initializeAtoms( int nAtoms, Atom** atomArray );
  void initializeBonds( int nBonds, Bond** bondArray,
                        bond_pair* the_bonds );
  void initializeBends( int nBends, Bend** bendArray,
                        bend_set* the_bends );
  void initializeTorsions( int nTorsions, Torsion** torsionArray,
                           torsion_set* the_torsions );

  void initForceField( int ljMixRule );

private:
  
  void fastForward( char* stopText, char* searchOwner );
};

class LJFF : public ForceFields{

public:
  LJFF();
  virtual ~LJFF();
  

  void readParams();
  void cleanMe( void );

  void initializeAtoms( int nAtoms, Atom** atomArray );
  void initializeBonds( int nBonds, Bond** bondArray,
                        bond_pair* the_bonds );
  void initializeBends( int nBends, Bend** bendArray,
                        bend_set* the_bends );
  void initializeTorsions( int nTorsions, Torsion** torsionArray,
                           torsion_set* the_torsions );

  void initForceField( int ljMixRule );

private:

  void fastForward( char* stopText, char* searchOwner );

};

class EAM_FF : public ForceFields{

public:
  EAM_FF();
  virtual ~EAM_FF();
  

  void readParams();
  void cleanMe( void );

  void initializeAtoms( int nAtoms, Atom** atomArray );
  void initializeBonds( int nBonds, Bond** bondArray,
                        bond_pair* the_bonds );
  void initializeBends( int nBends, Bend** bendArray,
                        bend_set* the_bends );
  void initializeTorsions( int nTorsions, Torsion** torsionArray,
                           torsion_set* the_torsions );

  void initForceField( int ljMixRule );

  void calcRcut( void );
private:

  void fastForward( char* stopText, char* searchOwner );
  
  double eamRcut;
};

class WATER : public ForceFields{

public:
  WATER();
  virtual ~WATER();

  void readParams();
  void cleanMe( void );
  void initializeAtoms( int nAtoms, Atom** atomArray );
  void initializeBonds( int nBonds, Bond** bondArray,
                        bond_pair* the_bonds );
  void initializeBends( int nBends, Bend** bendArray,
                        bend_set* the_bends );
  void initializeTorsions( int nTorsions, Torsion** torsionArray,
                           torsion_set* the_torsions );
  void initForceField( int ljMixRule );

private:
  
  void fastForward( char* stopText, char* searchOwner );
  void sectionSearch( char* secHead, char* stopText, char* searchOwner );

};

#endif

Revision:	1180
Committed:	Thu May 20 20:24:07 2004 UTC (20 years, 1 month ago) by chrisfen
File size:	4255 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.
#	Content
1	#ifndef __FORCEFIELDS_H__
2	#define __FORCEFIELDS_H__
3
4	#define MK_STR(s) # s
5	#define STR_DEFINE(t, s) t = MK_STR(s)
6
7
8	#include <stdio.h>
9	#include <stdlib.h>
10	#include <math.h>
11
12	#include "Atom.hpp"
13	#include "SimInfo.hpp"
14	#include "StuntDouble.hpp"
15
16	#ifdef IS_MPI
17	#include "mpiForceField.h"
18	#endif
19
20	#include "fForceField.h"
21	#include "fortranWrapDefines.hpp"
22
23	class bond_pair{
24	public:
25	bond_pair(){}
26	~bond_pair(){}
27
28	int a;
29	int b;
30	};
31
32	class bend_set{
33	public:
34	bend_set(){ isGhost = 0; }
35	~bend_set(){}
36
37	int ghost;
38	int isGhost;
39
40	int a;
41	int b;
42	int c;
43	};
44
45	class torsion_set{
46	public:
47	torsion_set(){}
48	~torsion_set(){}
49
50	int a;
51	int b;
52	int c;
53	int d;
54	};
55
56
57
58	class ForceFields{
59
60	public:
61	ForceFields(){ frcFile = NULL; entry_plug = NULL; }
62	virtual ~ForceFields(){}
63
64	void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
65
66	virtual void readParams( void ) = 0;
67	virtual void cleanMe( void ) = 0;
68
69
70	virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
71	virtual void initializeBonds( int nBonds, Bond** bondArray,
72	bond_pair* the_bonds ) = 0;
73	virtual void initializeBends( int nBends, Bend** bendArray,
74	bend_set* the_bends ) = 0;
75	virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
76	torsion_set* the_torsions ) = 0;
77	virtual void initForceField( int ljMixRule ) = 0;
78	virtual void initRestraints();
79	virtual void dumpzAngle();
80
81	virtual void calcRcut( void );
82	virtual void setRcut( double LJrcut );
83	virtual void doForces( int calcPot, int calcStress );
84
85	void setFortranForceLoop( doForceLoop_TD fsub ){
86	fortranForceLoop = fsub;
87	}
88
89	protected:
90
91	void initFortran( int ljMixPolicy, int useReactionField );
92	doForceLoop_TD fortranForceLoop;
93
94	FILE *frcFile;
95	SimInfo* entry_plug;
96
97	int lineNum;
98	char readLine[500];
99	char* eof_test;
100	double bigSigma;
101
102	vector<StuntDouble*> myStunts;
103
104	};
105
106
107	class DUFF : public ForceFields{
108
109	public:
110	DUFF();
111	virtual ~DUFF();
112
113	void readParams();
114	void cleanMe( void );
115
116	void initializeAtoms( int nAtoms, Atom** atomArray );
117	void initializeBonds( int nBonds, Bond** bondArray,
118	bond_pair* the_bonds );
119	void initializeBends( int nBends, Bend** bendArray,
120	bend_set* the_bends );
121	void initializeTorsions( int nTorsions, Torsion** torsionArray,
122	torsion_set* the_torsions );
123
124	void initForceField( int ljMixRule );
125
126	private:
127
128	void fastForward( char* stopText, char* searchOwner );
129	};
130
131	class LJFF : public ForceFields{
132
133	public:
134	LJFF();
135	virtual ~LJFF();
136
137
138	void readParams();
139	void cleanMe( void );
140
141	void initializeAtoms( int nAtoms, Atom** atomArray );
142	void initializeBonds( int nBonds, Bond** bondArray,
143	bond_pair* the_bonds );
144	void initializeBends( int nBends, Bend** bendArray,
145	bend_set* the_bends );
146	void initializeTorsions( int nTorsions, Torsion** torsionArray,
147	torsion_set* the_torsions );
148
149	void initForceField( int ljMixRule );
150
151	private:
152
153	void fastForward( char* stopText, char* searchOwner );
154
155	};
156
157	class EAM_FF : public ForceFields{
158
159	public:
160	EAM_FF();
161	virtual ~EAM_FF();
162
163
164	void readParams();
165	void cleanMe( void );
166
167	void initializeAtoms( int nAtoms, Atom** atomArray );
168	void initializeBonds( int nBonds, Bond** bondArray,
169	bond_pair* the_bonds );
170	void initializeBends( int nBends, Bend** bendArray,
171	bend_set* the_bends );
172	void initializeTorsions( int nTorsions, Torsion** torsionArray,
173	torsion_set* the_torsions );
174
175	void initForceField( int ljMixRule );
176
177	void calcRcut( void );
178	private:
179
180	void fastForward( char* stopText, char* searchOwner );
181
182	double eamRcut;
183	};
184
185	class WATER : public ForceFields{
186
187	public:
188	WATER();
189	virtual ~WATER();
190
191	void readParams();
192	void cleanMe( void );
193	void initializeAtoms( int nAtoms, Atom** atomArray );
194	void initializeBonds( int nBonds, Bond** bondArray,
195	bond_pair* the_bonds );
196	void initializeBends( int nBends, Bend** bendArray,
197	bend_set* the_bends );
198	void initializeTorsions( int nTorsions, Torsion** torsionArray,
199	torsion_set* the_torsions );
200	void initForceField( int ljMixRule );
201
202	private:
203
204	void fastForward( char* stopText, char* searchOwner );
205	void sectionSearch( char* secHead, char* stopText, char* searchOwner );
206
207	};
208
209	#endif
210