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;

};


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:	1187
Committed:	Sat May 22 18:16:18 2004 UTC (20 years, 1 month ago) by chrisfen
File size:	4221 byte(s)
Log Message:	Fixed Thermodynamic integration code.
#	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	};
103
104
105	class DUFF : public ForceFields{
106
107	public:
108	DUFF();
109	virtual ~DUFF();
110
111	void readParams();
112	void cleanMe( void );
113
114	void initializeAtoms( int nAtoms, Atom** atomArray );
115	void initializeBonds( int nBonds, Bond** bondArray,
116	bond_pair* the_bonds );
117	void initializeBends( int nBends, Bend** bendArray,
118	bend_set* the_bends );
119	void initializeTorsions( int nTorsions, Torsion** torsionArray,
120	torsion_set* the_torsions );
121
122	void initForceField( int ljMixRule );
123
124	private:
125
126	void fastForward( char* stopText, char* searchOwner );
127	};
128
129	class LJFF : public ForceFields{
130
131	public:
132	LJFF();
133	virtual ~LJFF();
134
135
136	void readParams();
137	void cleanMe( void );
138
139	void initializeAtoms( int nAtoms, Atom** atomArray );
140	void initializeBonds( int nBonds, Bond** bondArray,
141	bond_pair* the_bonds );
142	void initializeBends( int nBends, Bend** bendArray,
143	bend_set* the_bends );
144	void initializeTorsions( int nTorsions, Torsion** torsionArray,
145	torsion_set* the_torsions );
146
147	void initForceField( int ljMixRule );
148
149	private:
150
151	void fastForward( char* stopText, char* searchOwner );
152
153	};
154
155	class EAM_FF : public ForceFields{
156
157	public:
158	EAM_FF();
159	virtual ~EAM_FF();
160
161
162	void readParams();
163	void cleanMe( void );
164
165	void initializeAtoms( int nAtoms, Atom** atomArray );
166	void initializeBonds( int nBonds, Bond** bondArray,
167	bond_pair* the_bonds );
168	void initializeBends( int nBends, Bend** bendArray,
169	bend_set* the_bends );
170	void initializeTorsions( int nTorsions, Torsion** torsionArray,
171	torsion_set* the_torsions );
172
173	void initForceField( int ljMixRule );
174
175	void calcRcut( void );
176	private:
177
178	void fastForward( char* stopText, char* searchOwner );
179
180	double eamRcut;
181	};
182
183	class WATER : public ForceFields{
184
185	public:
186	WATER();
187	virtual ~WATER();
188
189	void readParams();
190	void cleanMe( void );
191	void initializeAtoms( int nAtoms, Atom** atomArray );
192	void initializeBonds( int nBonds, Bond** bondArray,
193	bond_pair* the_bonds );
194	void initializeBends( int nBends, Bend** bendArray,
195	bend_set* the_bends );
196	void initializeTorsions( int nTorsions, Torsion** torsionArray,
197	torsion_set* the_torsions );
198	void initForceField( int ljMixRule );
199
200	private:
201
202	void fastForward( char* stopText, char* searchOwner );
203	void sectionSearch( char* secHead, char* stopText, char* searchOwner );
204
205	};
206
207	#endif
208