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_env = "FORCE_PARAM_PATH";
    ffPath = getenv( ffPath_env );
    if( ffPath == NULL ) {
      STR_DEFINE(ffPath, FRC_PATH );
    }   
  }
  ForceFields(char * theVariant){ 
    frcFile = NULL; 
    entry_plug = NULL; 
    has_variant=1; 
    strcpy(variant, theVariant); 
    ffPath_env = "FORCE_PARAM_PATH";
    ffPath = getenv( ffPath_env );
    if( ffPath == NULL ) {
      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;
  char variant[100];
  short int has_variant;
  double bigSigma;

  ifstrstream forceFile;
  map<string, AtomType*> atomTypeMap;
  char* ffPath_env;
  char* ffPath;

};


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

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(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:	1650
Committed:	Tue Oct 26 22:24:52 2004 UTC (19 years, 8 months ago) by gezelter
File size:	5525 byte(s)
Log Message:	forcefield refactoring for shapes
#	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	frcFile = NULL;
66	entry_plug = NULL;
67	has_variant=0;
68	ffPath_env = "FORCE_PARAM_PATH";
69	ffPath = getenv( ffPath_env );
70	if( ffPath == NULL ) {
71	STR_DEFINE(ffPath, FRC_PATH );
72	}
73	}
74	ForceFields(char * theVariant){
75	frcFile = NULL;
76	entry_plug = NULL;
77	has_variant=1;
78	strcpy(variant, theVariant);
79	ffPath_env = "FORCE_PARAM_PATH";
80	ffPath = getenv( ffPath_env );
81	if( ffPath == NULL ) {
82	STR_DEFINE(ffPath, FRC_PATH );
83	}
84	}
85	virtual ~ForceFields(){}
86
87	void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
88
89	virtual void readParams( void ) = 0;
90
91	virtual void cleanMe( void ) = 0;
92
93
94	virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
95	virtual void initializeBonds( int nBonds, Bond** bondArray,
96	bond_pair* the_bonds ) = 0;
97	virtual void initializeBends( int nBends, Bend** bendArray,
98	bend_set* the_bends ) = 0;
99	virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
100	torsion_set* the_torsions ) = 0;
101	virtual void initForceField() = 0;
102	virtual void initRestraints();
103	virtual void dumpzAngle();
104
105	virtual void calcRcut( void );
106	virtual void setRcut( double LJrcut );
107	virtual void doForces( int calcPot, int calcStress );
108
109	protected:
110
111	void initFortran( int useReactionField );
112
113	FILE *frcFile;
114	SimInfo* entry_plug;
115
116	int lineNum;
117	char readLine[500];
118	char* eof_test;
119	char variant[100];
120	short int has_variant;
121	double bigSigma;
122
123	ifstrstream forceFile;
124	map<string, AtomType*> atomTypeMap;
125	char* ffPath_env;
126	char* ffPath;
127
128	};
129
130
131	class DUFF : public ForceFields{
132
133	public:
134	DUFF();
135	virtual ~DUFF();
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	void initForceField();
149
150	private:
151
152	void fastForward( char* stopText, char* searchOwner );
153	};
154
155	class LJFF : public ForceFields{
156
157	public:
158	LJFF();
159	virtual ~LJFF();
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( );
174
175
176	private:
177
178	void fastForward( char* stopText, char* searchOwner );
179
180	};
181
182	class EAM_FF : public ForceFields{
183
184	public:
185	EAM_FF();
186	EAM_FF(char* the_variant);
187	virtual ~EAM_FF();
188
189
190	void readParams();
191	void cleanMe( void );
192
193	void initializeAtoms( int nAtoms, Atom** atomArray );
194	void initializeBonds( int nBonds, Bond** bondArray,
195	bond_pair* the_bonds );
196	void initializeBends( int nBends, Bend** bendArray,
197	bend_set* the_bends );
198	void initializeTorsions( int nTorsions, Torsion** torsionArray,
199	torsion_set* the_torsions );
200
201	void initForceField();
202
203	void calcRcut( void );
204
205	private:
206
207	void fastForward( char* stopText, char* searchOwner );
208
209	double eamRcut;
210	};
211
212	class WATER : public ForceFields{
213
214	public:
215	WATER();
216	virtual ~WATER();
217
218	void readParams();
219	void cleanMe( void );
220	void initializeAtoms( int nAtoms, Atom** atomArray );
221	void initializeBonds( int nBonds, Bond** bondArray,
222	bond_pair* the_bonds );
223	void initializeBends( int nBends, Bend** bendArray,
224	bend_set* the_bends );
225	void initializeTorsions( int nTorsions, Torsion** torsionArray,
226	torsion_set* the_torsions );
227	void initForceField();
228
229
230	private:
231
232	void fastForward( char* stopText, char* searchOwner );
233	void sectionSearch( char* secHead, char* stopText, char* searchOwner );
234
235	};
236
237	class Shapes_FF : public ForceFields{
238
239	public:
240	Shapes_FF() : ForceFields() {};
241	Shapes_FF(char* the_variant) : ForceFields(the_variant) {};
242	virtual ~Shapes_FF();
243
244	void readParams();
245	void cleanMe( void );
246
247	void initializeAtoms( int nAtoms, Atom** atomArray );
248	void initializeBonds( int nBonds, Bond** bondArray,
249	bond_pair* the_bonds );
250	void initializeBends( int nBends, Bend** bendArray,
251	bend_set* the_bends );
252	void initializeTorsions( int nTorsions, Torsion** torsionArray,
253	torsion_set* the_torsions );
254
255	void initForceField();
256
257	void parseShapeFile(string shapeFileName, ShapeAtomType* st);
258
259	void calcRcut( void );
260
261	private:
262
263	double findLargestContactDistance(ShapeAtomType* st);
264	double shapesRcut;
265
266	};
267
268
269	#endif
270