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 <string>
#include <map>

#include "primitives/Atom.hpp"
#include "brains/SimInfo.hpp"
#include "primitives/StuntDouble.hpp"
#include "types/ShapeAtomType.hpp"
#include "io/basic_ifstrstream.hpp"

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

using namespace std;
using namespace oopse;

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;
    ffPath = getenv("FORCE_PARAM_PATH");
    if( ffPath.empty() ) {
      STR_DEFINE(ffPath, FRC_PATH );
    }   
  }
  ForceFields(string theVariant){ 
    frcFile = NULL; 
    entry_plug = NULL; 
    has_variant=1; 
    variant = theVariant;
    ffPath = getenv("FORCE_PARAM_PATH");
    if( ffPath.empty() ) {
      STR_DEFINE(ffPath, FRC_PATH );
    }   
  }
  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 );

protected:
  
  void initFortran( int useReactionField );
  
  FILE *frcFile;
  SimInfo* entry_plug;
  
  int lineNum;
  char readLine[500];
  char* eof_test;
  short int has_variant;
  double bigSigma;

  string ffPath;
  ifstrstream forceFile;
  bool hasVariant;
  string variant;
  map<string, AtomType*> atomTypeMap;
  // map<pair<string,string>, BondType*> bondTypeMap;
  // map<tuple3<string,string,string>, BendType*> bendTypeMap;
  // map<tuple4<string,string,string,string>, TorsionType*> torsionTypeMap;

};


class DUFF : public ForceFields{

public:
  DUFF() : ForceFields() {};
  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();

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

class LJFF : public ForceFields{

public:
  LJFF() : ForceFields() {};
  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( );


private:

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

};

class EAM_FF : public ForceFields{

public:
  EAM_FF() : ForceFields();
  EAM_FF(string the_variant) : ForceFields(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 );

private:

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

class WATER : public ForceFields{

public:
  WATER() : ForceFields() {};
  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();


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

};

class Shapes_FF : public ForceFields{

public:
  Shapes_FF() : ForceFields() {};
  Shapes_FF(char* the_variant) : ForceFields(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 parseShapeFile(string shapeFileName, ShapeAtomType* st);

  void calcRcut( void );

private:

  double findLargestContactDistance(ShapeAtomType* st);
  double shapesRcut;

};


#endif

Revision:	1655
Committed:	Wed Oct 27 02:20:29 2004 UTC (19 years, 8 months ago) by gezelter
Original Path:	*trunk/OOPSE-3.0/src/UseTheForce/ForceFields.hpp*
File size:	5746 byte(s)
Log Message:	subclass foo
#	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			#include <stdio.h>
8			#include <stdlib.h>
9			#include <math.h>
10	gezelter	1650	#include <string>
11			#include <map>
12	gezelter	1490
13	tim	1492	#include "primitives/Atom.hpp"
14			#include "brains/SimInfo.hpp"
15			#include "primitives/StuntDouble.hpp"
16	gezelter	1650	#include "types/ShapeAtomType.hpp"
17			#include "io/basic_ifstrstream.hpp"
18	gezelter	1490
19			#ifdef IS_MPI
20	tim	1492	#include "UseTheForce/mpiForceField.h"
21	gezelter	1490	#endif
22
23	gezelter	1650	using namespace std;
24			using namespace oopse;
25
26	gezelter	1490	class bond_pair{
27			public:
28			bond_pair(){}
29			~bond_pair(){}
30
31			int a;
32			int b;
33			};
34
35			class bend_set{
36			public:
37			bend_set(){ isGhost = 0; }
38			~bend_set(){}
39
40			int ghost;
41			int isGhost;
42
43			int a;
44			int b;
45			int c;
46			};
47
48			class torsion_set{
49			public:
50			torsion_set(){}
51			~torsion_set(){}
52
53			int a;
54			int b;
55			int c;
56			int d;
57			};
58
59
60
61			class ForceFields{
62
63			public:
64	gezelter	1650	ForceFields(){
65			frcFile = NULL;
66			entry_plug = NULL;
67			has_variant=0;
68	gezelter	1653	ffPath = getenv("FORCE_PARAM_PATH");
69			if( ffPath.empty() ) {
70	gezelter	1650	STR_DEFINE(ffPath, FRC_PATH );
71			}
72			}
73	gezelter	1653	ForceFields(string theVariant){
74	gezelter	1650	frcFile = NULL;
75			entry_plug = NULL;
76			has_variant=1;
77	gezelter	1653	variant = theVariant;
78			ffPath = getenv("FORCE_PARAM_PATH");
79			if( ffPath.empty() ) {
80	gezelter	1650	STR_DEFINE(ffPath, FRC_PATH );
81			}
82			}
83	gezelter	1490	virtual ~ForceFields(){}
84
85			void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
86
87			virtual void readParams( void ) = 0;
88
89			virtual void cleanMe( void ) = 0;
90
91
92			virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
93			virtual void initializeBonds( int nBonds, Bond** bondArray,
94			bond_pair* the_bonds ) = 0;
95			virtual void initializeBends( int nBends, Bend** bendArray,
96			bend_set* the_bends ) = 0;
97			virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
98			torsion_set* the_torsions ) = 0;
99	gezelter	1628	virtual void initForceField() = 0;
100	gezelter	1490	virtual void initRestraints();
101			virtual void dumpzAngle();
102
103			virtual void calcRcut( void );
104			virtual void setRcut( double LJrcut );
105			virtual void doForces( int calcPot, int calcStress );
106
107			protected:
108
109	gezelter	1628	void initFortran( int useReactionField );
110	chuckv	1617
111	gezelter	1490	FILE *frcFile;
112			SimInfo* entry_plug;
113
114			int lineNum;
115			char readLine[500];
116			char* eof_test;
117			short int has_variant;
118			double bigSigma;
119
120	gezelter	1653	string ffPath;
121	gezelter	1650	ifstrstream forceFile;
122	gezelter	1653	bool hasVariant;
123			string variant;
124	gezelter	1650	map<string, AtomType*> atomTypeMap;
125	gezelter	1653	// map<pair<string,string>, BondType*> bondTypeMap;
126			// map<tuple3<string,string,string>, BendType*> bendTypeMap;
127			// map<tuple4<string,string,string,string>, TorsionType*> torsionTypeMap;
128	gezelter	1650
129	gezelter	1490	};
130
131
132			class DUFF : public ForceFields{
133
134			public:
135	gezelter	1655	DUFF() : ForceFields() {};
136	gezelter	1490	virtual ~DUFF();
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	gezelter	1628	void initForceField();
150	gezelter	1490
151			private:
152
153			void fastForward( char* stopText, char* searchOwner );
154			};
155
156			class LJFF : public ForceFields{
157
158			public:
159	gezelter	1655	LJFF() : ForceFields() {};
160	gezelter	1490	virtual ~LJFF();
161
162
163			void readParams();
164			void cleanMe( void );
165
166			void initializeAtoms( int nAtoms, Atom** atomArray );
167			void initializeBonds( int nBonds, Bond** bondArray,
168			bond_pair* the_bonds );
169			void initializeBends( int nBends, Bend** bendArray,
170			bend_set* the_bends );
171			void initializeTorsions( int nTorsions, Torsion** torsionArray,
172			torsion_set* the_torsions );
173
174	gezelter	1628	void initForceField( );
175	gezelter	1490
176	gezelter	1650
177	gezelter	1490	private:
178
179			void fastForward( char* stopText, char* searchOwner );
180
181			};
182
183			class EAM_FF : public ForceFields{
184
185			public:
186	gezelter	1655	EAM_FF() : ForceFields();
187			EAM_FF(string the_variant) : ForceFields(the_variant);
188	gezelter	1490	virtual ~EAM_FF();
189
190
191			void readParams();
192			void cleanMe( void );
193
194			void initializeAtoms( int nAtoms, Atom** atomArray );
195			void initializeBonds( int nBonds, Bond** bondArray,
196			bond_pair* the_bonds );
197			void initializeBends( int nBends, Bend** bendArray,
198			bend_set* the_bends );
199			void initializeTorsions( int nTorsions, Torsion** torsionArray,
200			torsion_set* the_torsions );
201
202	gezelter	1628	void initForceField();
203	gezelter	1490
204			void calcRcut( void );
205	gezelter	1650
206	gezelter	1490	private:
207
208			void fastForward( char* stopText, char* searchOwner );
209
210			double eamRcut;
211			};
212
213			class WATER : public ForceFields{
214
215			public:
216	gezelter	1655	WATER() : ForceFields() {};
217	gezelter	1490	virtual ~WATER();
218
219			void readParams();
220			void cleanMe( void );
221			void initializeAtoms( int nAtoms, Atom** atomArray );
222			void initializeBonds( int nBonds, Bond** bondArray,
223			bond_pair* the_bonds );
224			void initializeBends( int nBends, Bend** bendArray,
225			bend_set* the_bends );
226			void initializeTorsions( int nTorsions, Torsion** torsionArray,
227			torsion_set* the_torsions );
228	gezelter	1628	void initForceField();
229	gezelter	1490
230	gezelter	1650
231	gezelter	1490	private:
232
233			void fastForward( char* stopText, char* searchOwner );
234			void sectionSearch( char* secHead, char* stopText, char* searchOwner );
235
236			};
237
238	gezelter	1520	class Shapes_FF : public ForceFields{
239
240			public:
241	gezelter	1650	Shapes_FF() : ForceFields() {};
242			Shapes_FF(char* the_variant) : ForceFields(the_variant) {};
243	gezelter	1520	virtual ~Shapes_FF();
244
245	gezelter	1650	void readParams();
246	gezelter	1520	void cleanMe( void );
247
248			void initializeAtoms( int nAtoms, Atom** atomArray );
249			void initializeBonds( int nBonds, Bond** bondArray,
250			bond_pair* the_bonds );
251			void initializeBends( int nBends, Bend** bendArray,
252			bend_set* the_bends );
253			void initializeTorsions( int nTorsions, Torsion** torsionArray,
254			torsion_set* the_torsions );
255
256	gezelter	1628	void initForceField();
257	gezelter	1520
258	gezelter	1650	void parseShapeFile(string shapeFileName, ShapeAtomType* st);
259
260	gezelter	1520	void calcRcut( void );
261	chrisfen	1646
262	gezelter	1520	private:
263	gezelter	1650
264			double findLargestContactDistance(ShapeAtomType* st);
265	chrisfen	1646	double shapesRcut;
266	gezelter	1520
267			};
268
269
270	gezelter	1490	#endif
271