src/UseTheForce/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 "primitives/Atom.hpp"
#include "brains/SimInfo.hpp"
#include "primitives/StuntDouble.hpp"

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

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() = 0;
  virtual void initRestraints();
  virtual void dumpzAngle();

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

  virtual double getAtomTypeMass(char* atomType) = 0;

 
protected:
  
  void initFortran( int useReactionField );
  

  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();
  double getAtomTypeMass(char* atomType);

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( );
  double getAtomTypeMass(char* atomType);

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();

  void calcRcut( void );
  double getAtomTypeMass(char* atomType);
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();
  double getAtomTypeMass(char* atomType);

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

};

class Shapes_FF : public ForceFields{

public:
  Shapes_FF();
  Shapes_FF(char* the_variant);
  virtual ~Shapes_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();

  void calcRcut( void );
  double getAtomTypeMass(char* atomType);
private:

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


#endif

Revision:	1628
Committed:	Thu Oct 21 20:15:31 2004 UTC (19 years, 8 months ago) by gezelter
Original Path:	*trunk/OOPSE-4/src/UseTheForce/ForceFields.hpp*
File size:	5101 byte(s)
Log Message:	Breaky Breaky. Fixey Fixey.
#	User	Rev	Content
1	gezelter	1490	#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	tim	1492	#include "primitives/Atom.hpp"
13			#include "brains/SimInfo.hpp"
14			#include "primitives/StuntDouble.hpp"
15	gezelter	1490
16			#ifdef IS_MPI
17	tim	1492	#include "UseTheForce/mpiForceField.h"
18	gezelter	1490	#endif
19
20			class bond_pair{
21			public:
22			bond_pair(){}
23			~bond_pair(){}
24
25			int a;
26			int b;
27			};
28
29			class bend_set{
30			public:
31			bend_set(){ isGhost = 0; }
32			~bend_set(){}
33
34			int ghost;
35			int isGhost;
36
37			int a;
38			int b;
39			int c;
40			};
41
42			class torsion_set{
43			public:
44			torsion_set(){}
45			~torsion_set(){}
46
47			int a;
48			int b;
49			int c;
50			int d;
51			};
52
53
54
55			class ForceFields{
56
57			public:
58			ForceFields(){ frcFile = NULL; entry_plug = NULL; has_variant=0;}
59			ForceFields(char * theVariant ){ frcFile = NULL; entry_plug = NULL; has_variant=1; strcpy(variant, theVariant); }
60			virtual ~ForceFields(){}
61
62			void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
63
64			virtual void readParams( void ) = 0;
65
66			virtual void cleanMe( void ) = 0;
67
68
69			virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
70			virtual void initializeBonds( int nBonds, Bond** bondArray,
71			bond_pair* the_bonds ) = 0;
72			virtual void initializeBends( int nBends, Bend** bendArray,
73			bend_set* the_bends ) = 0;
74			virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
75			torsion_set* the_torsions ) = 0;
76	gezelter	1628	virtual void initForceField() = 0;
77	gezelter	1490	virtual void initRestraints();
78			virtual void dumpzAngle();
79
80			virtual void calcRcut( void );
81			virtual void setRcut( double LJrcut );
82			virtual void doForces( int calcPot, int calcStress );
83
84			virtual double getAtomTypeMass(char* atomType) = 0;
85
86	chuckv	1617
87	gezelter	1490	protected:
88
89	gezelter	1628	void initFortran( int useReactionField );
90	chuckv	1617
91	gezelter	1490
92			FILE *frcFile;
93			SimInfo* entry_plug;
94
95			int lineNum;
96			char readLine[500];
97			char* eof_test;
98			char variant[100];
99			short int has_variant;
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	gezelter	1628	void initForceField();
123	gezelter	1490	double getAtomTypeMass(char* atomType);
124
125			private:
126
127			void fastForward( char* stopText, char* searchOwner );
128			};
129
130			class LJFF : public ForceFields{
131
132			public:
133			LJFF();
134			virtual ~LJFF();
135
136
137			void readParams();
138			void cleanMe( void );
139
140			void initializeAtoms( int nAtoms, Atom** atomArray );
141			void initializeBonds( int nBonds, Bond** bondArray,
142			bond_pair* the_bonds );
143			void initializeBends( int nBends, Bend** bendArray,
144			bend_set* the_bends );
145			void initializeTorsions( int nTorsions, Torsion** torsionArray,
146			torsion_set* the_torsions );
147
148	gezelter	1628	void initForceField( );
149	gezelter	1490	double getAtomTypeMass(char* atomType);
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			EAM_FF(char* the_variant);
162			virtual ~EAM_FF();
163
164
165			void readParams();
166			void cleanMe( void );
167
168			void initializeAtoms( int nAtoms, Atom** atomArray );
169			void initializeBonds( int nBonds, Bond** bondArray,
170			bond_pair* the_bonds );
171			void initializeBends( int nBends, Bend** bendArray,
172			bend_set* the_bends );
173			void initializeTorsions( int nTorsions, Torsion** torsionArray,
174			torsion_set* the_torsions );
175
176	gezelter	1628	void initForceField();
177	gezelter	1490
178			void calcRcut( void );
179			double getAtomTypeMass(char* atomType);
180			private:
181
182			void fastForward( char* stopText, char* searchOwner );
183
184			double eamRcut;
185			};
186
187			class WATER : public ForceFields{
188
189			public:
190			WATER();
191			virtual ~WATER();
192
193			void readParams();
194			void cleanMe( void );
195			void initializeAtoms( int nAtoms, Atom** atomArray );
196			void initializeBonds( int nBonds, Bond** bondArray,
197			bond_pair* the_bonds );
198			void initializeBends( int nBends, Bend** bendArray,
199			bend_set* the_bends );
200			void initializeTorsions( int nTorsions, Torsion** torsionArray,
201			torsion_set* the_torsions );
202	gezelter	1628	void initForceField();
203	gezelter	1490	double getAtomTypeMass(char* atomType);
204
205			private:
206
207			void fastForward( char* stopText, char* searchOwner );
208			void sectionSearch( char* secHead, char* stopText, char* searchOwner );
209
210			};
211
212	gezelter	1520	class Shapes_FF : public ForceFields{
213
214			public:
215			Shapes_FF();
216			Shapes_FF(char* the_variant);
217			virtual ~Shapes_FF();
218
219
220			void readParams();
221			void cleanMe( void );
222
223			void initializeAtoms( int nAtoms, Atom** atomArray );
224			void initializeBonds( int nBonds, Bond** bondArray,
225			bond_pair* the_bonds );
226			void initializeBends( int nBends, Bend** bendArray,
227			bend_set* the_bends );
228			void initializeTorsions( int nTorsions, Torsion** torsionArray,
229			torsion_set* the_torsions );
230
231	gezelter	1628	void initForceField();
232	gezelter	1520
233			void calcRcut( void );
234			double getAtomTypeMass(char* atomType);
235			private:
236
237			void fastForward( char* stopText, char* searchOwner );
238
239			double shapesRcut;
240			};
241
242
243	gezelter	1490	#endif
244