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

    char* force_param_path;
    frcFile = NULL; 
    entry_plug = NULL; 
    has_variant=0;

    force_param_path = getenv("FORCE_PARAM_PATH");
    if (force_param_path != NULL) {
      ffPath = force_param_path;
    } else {
      ffPath = "";
    }

    if( ffPath.empty() ) {
      STR_DEFINE(ffPath, FRC_PATH );
    }   
  }
  ForceFields(const string &theVariant){ 
    char* force_param_path;
    frcFile = NULL; 
    entry_plug = NULL; 
    has_variant=1; 
    variant = theVariant;

    force_param_path = getenv("FORCE_PARAM_PATH");
    if (force_param_path != NULL) {
      ffPath = force_param_path;
    } else {
      ffPath = "";
    }

    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();
  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();
  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();
  EAM_FF(const string &theVariant);

  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();
  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(const string &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:	1683
Committed:	Thu Oct 28 22:34:02 2004 UTC (19 years, 8 months ago)
File size:	5963 byte(s)
Log Message:	This commit was manufactured by cvs2svn to create branch 'new_design'.
#	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	#include <stdio.h>
8	#include <stdlib.h>
9	#include <math.h>
10	#include <string>
11	#include <map>
12
13	#include "primitives/Atom.hpp"
14	#include "brains/SimInfo.hpp"
15	#include "primitives/StuntDouble.hpp"
16	#include "types/ShapeAtomType.hpp"
17	#include "io/basic_ifstrstream.hpp"
18
19	#ifdef IS_MPI
20	#include "UseTheForce/mpiForceField.h"
21	#endif
22
23	using namespace std;
24	using namespace oopse;
25
26	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	ForceFields(){
65
66	char* force_param_path;
67	frcFile = NULL;
68	entry_plug = NULL;
69	has_variant=0;
70
71	force_param_path = getenv("FORCE_PARAM_PATH");
72	if (force_param_path != NULL) {
73	ffPath = force_param_path;
74	} else {
75	ffPath = "";
76	}
77
78	if( ffPath.empty() ) {
79	STR_DEFINE(ffPath, FRC_PATH );
80	}
81	}
82	ForceFields(const string &theVariant){
83	char* force_param_path;
84	frcFile = NULL;
85	entry_plug = NULL;
86	has_variant=1;
87	variant = theVariant;
88
89	force_param_path = getenv("FORCE_PARAM_PATH");
90	if (force_param_path != NULL) {
91	ffPath = force_param_path;
92	} else {
93	ffPath = "";
94	}
95
96	if( ffPath.empty() ) {
97	STR_DEFINE(ffPath, FRC_PATH );
98	}
99	}
100	virtual ~ForceFields(){}
101
102	void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
103
104	virtual void readParams( void ) = 0;
105
106	virtual void cleanMe( void ) = 0;
107
108
109	virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
110	virtual void initializeBonds( int nBonds, Bond** bondArray,
111	bond_pair* the_bonds ) = 0;
112	virtual void initializeBends( int nBends, Bend** bendArray,
113	bend_set* the_bends ) = 0;
114	virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
115	torsion_set* the_torsions ) = 0;
116	virtual void initForceField() = 0;
117	virtual void initRestraints();
118	virtual void dumpzAngle();
119
120	virtual void calcRcut( void );
121	virtual void setRcut( double LJrcut );
122	virtual void doForces( int calcPot, int calcStress );
123
124	protected:
125
126	void initFortran( int useReactionField );
127
128	FILE *frcFile;
129	SimInfo* entry_plug;
130
131	int lineNum;
132	char readLine[500];
133	char* eof_test;
134	short int has_variant;
135	double bigSigma;
136
137	string ffPath;
138	ifstrstream forceFile;
139	bool hasVariant;
140	string variant;
141	map<string, AtomType*> atomTypeMap;
142	// map<pair<string,string>, BondType*> bondTypeMap;
143	// map<tuple3<string,string,string>, BendType*> bendTypeMap;
144	// map<tuple4<string,string,string,string>, TorsionType*> torsionTypeMap;
145
146	};
147
148
149	class DUFF : public ForceFields{
150
151	public:
152	DUFF();
153	virtual ~DUFF();
154
155	void readParams();
156	void cleanMe( void );
157
158	void initializeAtoms( int nAtoms, Atom** atomArray );
159	void initializeBonds( int nBonds, Bond** bondArray,
160	bond_pair* the_bonds );
161	void initializeBends( int nBends, Bend** bendArray,
162	bend_set* the_bends );
163	void initializeTorsions( int nTorsions, Torsion** torsionArray,
164	torsion_set* the_torsions );
165
166	void initForceField();
167
168	private:
169
170	void fastForward( char* stopText, char* searchOwner );
171	};
172
173	class LJFF : public ForceFields{
174
175	public:
176	LJFF();
177	virtual ~LJFF();
178
179
180	void readParams();
181	void cleanMe( void );
182
183	void initializeAtoms( int nAtoms, Atom** atomArray );
184	void initializeBonds( int nBonds, Bond** bondArray,
185	bond_pair* the_bonds );
186	void initializeBends( int nBends, Bend** bendArray,
187	bend_set* the_bends );
188	void initializeTorsions( int nTorsions, Torsion** torsionArray,
189	torsion_set* the_torsions );
190
191	void initForceField( );
192
193
194	private:
195
196	void fastForward( char* stopText, char* searchOwner );
197
198	};
199
200	class EAM_FF : public ForceFields{
201
202	public:
203
204	EAM_FF();
205	EAM_FF(const string &theVariant);
206
207	virtual ~EAM_FF();
208
209	void readParams();
210	void cleanMe( void );
211
212	void initializeAtoms( int nAtoms, Atom** atomArray );
213	void initializeBonds( int nBonds, Bond** bondArray,
214	bond_pair* the_bonds );
215	void initializeBends( int nBends, Bend** bendArray,
216	bend_set* the_bends );
217	void initializeTorsions( int nTorsions, Torsion** torsionArray,
218	torsion_set* the_torsions );
219
220	void initForceField();
221
222	void calcRcut( void );
223
224	private:
225
226	void fastForward( char* stopText, char* searchOwner );
227
228	double eamRcut;
229	};
230
231	class WATER : public ForceFields{
232
233	public:
234	WATER();
235	virtual ~WATER();
236
237	void readParams();
238	void cleanMe( void );
239	void initializeAtoms( int nAtoms, Atom** atomArray );
240	void initializeBonds( int nBonds, Bond** bondArray,
241	bond_pair* the_bonds );
242	void initializeBends( int nBends, Bend** bendArray,
243	bend_set* the_bends );
244	void initializeTorsions( int nTorsions, Torsion** torsionArray,
245	torsion_set* the_torsions );
246	void initForceField();
247
248
249	private:
250
251	void fastForward( char* stopText, char* searchOwner );
252	void sectionSearch( char* secHead, char* stopText, char* searchOwner );
253
254	};
255
256	class Shapes_FF : public ForceFields{
257
258	public:
259	Shapes_FF() : ForceFields() {};
260	Shapes_FF(const string &the_variant) : ForceFields(the_variant) {};
261	virtual ~Shapes_FF();
262
263	void readParams();
264	void cleanMe( void );
265
266	void initializeAtoms( int nAtoms, Atom** atomArray );
267	void initializeBonds( int nBonds, Bond** bondArray,
268	bond_pair* the_bonds );
269	void initializeBends( int nBends, Bend** bendArray,
270	bend_set* the_bends );
271	void initializeTorsions( int nTorsions, Torsion** torsionArray,
272	torsion_set* the_torsions );
273
274	void initForceField();
275
276	void parseShapeFile(string shapeFileName, ShapeAtomType* st);
277
278	void calcRcut( void );
279
280	private:
281
282	double findLargestContactDistance(ShapeAtomType* st);
283	double shapesRcut;
284
285	};
286
287
288	#endif
289