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; has_variant=0;}
  ForceFields(char * theVariant ){ frcFile = NULL; entry_plug = NULL; has_variant=1; strcpy(variant, theVariant); }
  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;
  char variant[100];
  short int has_variant;
  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();
  EAM_FF(char* the_variant);
  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:	1261
Committed:	Fri Jun 11 14:14:10 2004 UTC (20 years ago) by gezelter
File size:	4429 byte(s)
Log Message:	Modified EAM to use forceFieldVariant
#	User	Rev	Content
1	mmeineke	377	#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	gezelter	829	#include <stdio.h>
9			#include <stdlib.h>
10	chrisfen	1180	#include <math.h>
11	mmeineke	377
12			#include "Atom.hpp"
13			#include "SimInfo.hpp"
14	chrisfen	1180	#include "StuntDouble.hpp"
15	mmeineke	377
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	gezelter	1261	ForceFields(){ frcFile = NULL; entry_plug = NULL; has_variant=0;}
62			ForceFields(char * theVariant ){ frcFile = NULL; entry_plug = NULL; has_variant=1; strcpy(variant, theVariant); }
63	mmeineke	377	virtual ~ForceFields(){}
64
65			void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
66	mmeineke	420
67			virtual void readParams( void ) = 0;
68	gezelter	1261
69	mmeineke	420	virtual void cleanMe( void ) = 0;
70
71
72			virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
73			virtual void initializeBonds( int nBonds, Bond** bondArray,
74			bond_pair* the_bonds ) = 0;
75			virtual void initializeBends( int nBends, Bend** bendArray,
76			bend_set* the_bends ) = 0;
77			virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
78			torsion_set* the_torsions ) = 0;
79	mmeineke	377	virtual void initForceField( int ljMixRule ) = 0;
80	chrisfen	1180	virtual void initRestraints();
81			virtual void dumpzAngle();
82	mmeineke	420
83			virtual void calcRcut( void );
84	gezelter	1097	virtual void setRcut( double LJrcut );
85	mmeineke	377	virtual void doForces( int calcPot, int calcStress );
86
87	mmeineke	836	void setFortranForceLoop( doForceLoop_TD fsub ){
88	mmeineke	377	fortranForceLoop = fsub;
89			}
90
91			protected:
92
93			void initFortran( int ljMixPolicy, int useReactionField );
94	mmeineke	836	doForceLoop_TD fortranForceLoop;
95	mmeineke	377
96			FILE *frcFile;
97			SimInfo* entry_plug;
98
99			int lineNum;
100			char readLine[500];
101			char* eof_test;
102	gezelter	1261	char variant[100];
103			short int has_variant;
104	mmeineke	420	double bigSigma;
105	mmeineke	377
106			};
107
108
109	mmeineke	559	class DUFF : public ForceFields{
110	mmeineke	377
111			public:
112	mmeineke	559	DUFF();
113			virtual ~DUFF();
114	mmeineke	377
115	mmeineke	420	void readParams();
116			void cleanMe( void );
117
118			void initializeAtoms( int nAtoms, Atom** atomArray );
119			void initializeBonds( int nBonds, Bond** bondArray,
120			bond_pair* the_bonds );
121			void initializeBends( int nBends, Bend** bendArray,
122			bend_set* the_bends );
123			void initializeTorsions( int nTorsions, Torsion** torsionArray,
124			torsion_set* the_torsions );
125
126	mmeineke	424	void initForceField( int ljMixRule );
127
128	mmeineke	377	private:
129
130			void fastForward( char* stopText, char* searchOwner );
131			};
132
133	mmeineke	559	class LJFF : public ForceFields{
134	mmeineke	377
135			public:
136	mmeineke	559	LJFF();
137			virtual ~LJFF();
138	mmeineke	377
139
140	mmeineke	420	void readParams();
141			void cleanMe( void );
142
143			void initializeAtoms( int nAtoms, Atom** atomArray );
144			void initializeBonds( int nBonds, Bond** bondArray,
145			bond_pair* the_bonds );
146			void initializeBends( int nBends, Bend** bendArray,
147			bend_set* the_bends );
148			void initializeTorsions( int nTorsions, Torsion** torsionArray,
149			torsion_set* the_torsions );
150	mmeineke	424
151			void initForceField( int ljMixRule );
152
153	mmeineke	377	private:
154
155			void fastForward( char* stopText, char* searchOwner );
156	mmeineke	420
157	mmeineke	377	};
158	mmeineke	559
159	chuckv	500	class EAM_FF : public ForceFields{
160	mmeineke	377
161	chuckv	500	public:
162			EAM_FF();
163	gezelter	1261	EAM_FF(char* the_variant);
164	chuckv	500	virtual ~EAM_FF();
165
166
167			void readParams();
168			void cleanMe( void );
169
170			void initializeAtoms( int nAtoms, Atom** atomArray );
171			void initializeBonds( int nBonds, Bond** bondArray,
172			bond_pair* the_bonds );
173			void initializeBends( int nBends, Bend** bendArray,
174			bend_set* the_bends );
175			void initializeTorsions( int nTorsions, Torsion** torsionArray,
176			torsion_set* the_torsions );
177
178			void initForceField( int ljMixRule );
179
180	chuckv	657	void calcRcut( void );
181	chuckv	500	private:
182
183			void fastForward( char* stopText, char* searchOwner );
184	chuckv	657
185			double eamRcut;
186	chuckv	500	};
187
188	chrisfen	976	class WATER : public ForceFields{
189
190			public:
191			WATER();
192			virtual ~WATER();
193
194			void readParams();
195			void cleanMe( void );
196			void initializeAtoms( int nAtoms, Atom** atomArray );
197			void initializeBonds( int nBonds, Bond** bondArray,
198			bond_pair* the_bonds );
199			void initializeBends( int nBends, Bend** bendArray,
200			bend_set* the_bends );
201			void initializeTorsions( int nTorsions, Torsion** torsionArray,
202			torsion_set* the_torsions );
203			void initForceField( int ljMixRule );
204
205			private:
206
207			void fastForward( char* stopText, char* searchOwner );
208	chrisfen	999	void sectionSearch( char* secHead, char* stopText, char* searchOwner );
209
210	chrisfen	976	};
211
212	mmeineke	377	#endif
213