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 <cstdio>
#include <cstdlib>

#include "Atom.hpp"
#include "SimInfo.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; }
  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 calcRcut( void );
  virtual void doForces( int calcPot, int calcStress );

  void setFortranForceLoop( void (*fsub) doForceLoopList ){
    fortranForceLoop = fsub;
  }

protected:
  
  void initFortran( int ljMixPolicy, int useReactionField );
  void (*fortranForceLoop) doForceLoopList;

  FILE *frcFile;
  SimInfo* entry_plug;
  
  int lineNum;
  char readLine[500];
  char* eof_test;
  double bigSigma;

};

class TraPPEFF : public ForceFields{

public:
  TraPPEFF();
  virtual ~TraPPEFF();

  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 ) {}
  
};


class DipoleTestFF : public ForceFields{

public:
  DipoleTestFF();
  virtual ~DipoleTestFF();
  
  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 ) {}
};

class TraPPE_ExFF : public ForceFields{

public:
  TraPPE_ExFF();
  virtual ~TraPPE_ExFF();

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

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

class LJ_FF : public ForceFields{

public:
  LJ_FF();
  virtual ~LJ_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 );
private:

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

};

#endif

Revision:	420
Committed:	Thu Mar 27 17:32:03 2003 UTC (21 years, 3 months ago) by mmeineke
File size:	3740 byte(s)
Log Message:	LJ_FF has been converted to the new Molecule model. TraPPE_Ex is currently being updated. SimSetups routines are writtten, but not yet called.
#	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
8	#include <cstdio>
9	#include <cstdlib>
10
11	#include "Atom.hpp"
12	#include "SimInfo.hpp"
13
14	#ifdef IS_MPI
15	#include "mpiForceField.h"
16	#endif
17
18	#include "fForceField.h"
19	#include "fortranWrapDefines.hpp"
20
21	class bond_pair{
22	public:
23	bond_pair(){}
24	~bond_pair(){}
25
26	int a;
27	int b;
28	};
29
30	class bend_set{
31	public:
32	bend_set(){ isGhost = 0; }
33	~bend_set(){}
34
35	int ghost;
36	int isGhost;
37
38	int a;
39	int b;
40	int c;
41	};
42
43	class torsion_set{
44	public:
45	torsion_set(){}
46	~torsion_set(){}
47
48	int a;
49	int b;
50	int c;
51	int d;
52	};
53
54
55
56	class ForceFields{
57
58	public:
59	ForceFields(){ frcFile = NULL; entry_plug = NULL; }
60	virtual ~ForceFields(){}
61
62	void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
63
64	virtual void readParams( void ) = 0;
65	virtual void cleanMe( void ) = 0;
66
67
68	virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
69	virtual void initializeBonds( int nBonds, Bond** bondArray,
70	bond_pair* the_bonds ) = 0;
71	virtual void initializeBends( int nBends, Bend** bendArray,
72	bend_set* the_bends ) = 0;
73	virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
74	torsion_set* the_torsions ) = 0;
75	virtual void initForceField( int ljMixRule ) = 0;
76
77	virtual void calcRcut( void );
78	virtual void doForces( int calcPot, int calcStress );
79
80	void setFortranForceLoop( void (*fsub) doForceLoopList ){
81	fortranForceLoop = fsub;
82	}
83
84	protected:
85
86	void initFortran( int ljMixPolicy, int useReactionField );
87	void (*fortranForceLoop) doForceLoopList;
88
89	FILE *frcFile;
90	SimInfo* entry_plug;
91
92	int lineNum;
93	char readLine[500];
94	char* eof_test;
95	double bigSigma;
96
97	};
98
99	class TraPPEFF : public ForceFields{
100
101	public:
102	TraPPEFF();
103	virtual ~TraPPEFF();
104
105	void readParams(){}
106	void cleanMe( void ){}
107
108	void initializeAtoms( int nAtoms, Atom** atomArray ) {}
109	void initializeBonds( int nBonds, Bond** bondArray,
110	bond_pair* the_bonds ) {}
111	void initializeBends( int nBends, Bend** bendArray,
112	bend_set* the_bends ) {}
113	void initializeTorsions( int nTorsions, Torsion** torsionArray,
114	torsion_set* the_torsions ) {}
115
116	};
117
118
119	class DipoleTestFF : public ForceFields{
120
121	public:
122	DipoleTestFF();
123	virtual ~DipoleTestFF();
124
125	void readParams(){}
126	void cleanMe( void ){}
127
128	void initializeAtoms( int nAtoms, Atom** atomArray ) {}
129	void initializeBonds( int nBonds, Bond** bondArray,
130	bond_pair* the_bonds ) {}
131	void initializeBends( int nBends, Bend** bendArray,
132	bend_set* the_bends ) {}
133	void initializeTorsions( int nTorsions, Torsion** torsionArray,
134	torsion_set* the_torsions ) {}
135	};
136
137	class TraPPE_ExFF : public ForceFields{
138
139	public:
140	TraPPE_ExFF();
141	virtual ~TraPPE_ExFF();
142
143	void readParams();
144	void cleanMe( void );
145
146	void initializeAtoms( int nAtoms, Atom** atomArray );
147	void initializeBonds( int nBonds, Bond** bondArray,
148	bond_pair* the_bonds );
149	void initializeBends( int nBends, Bend** bendArray,
150	bend_set* the_bends );
151	void initializeTorsions( int nTorsions, Torsion** torsionArray,
152	torsion_set* the_torsions );
153
154	private:
155
156	void fastForward( char* stopText, char* searchOwner );
157	};
158
159	class LJ_FF : public ForceFields{
160
161	public:
162	LJ_FF();
163	virtual ~LJ_FF();
164
165
166	void readParams();
167	void cleanMe( void );
168
169	void initializeAtoms( int nAtoms, Atom** atomArray );
170	void initializeBonds( int nBonds, Bond** bondArray,
171	bond_pair* the_bonds );
172	void initializeBends( int nBends, Bend** bendArray,
173	bend_set* the_bends );
174	void initializeTorsions( int nTorsions, Torsion** torsionArray,
175	torsion_set* the_torsions );
176	private:
177
178	void fastForward( char* stopText, char* searchOwner );
179
180	};
181
182	#endif
183