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.
#	User	Rev	Content
1	mmeineke	377	#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	mmeineke	420
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	mmeineke	377	virtual void initForceField( int ljMixRule ) = 0;
76	mmeineke	420
77			virtual void calcRcut( void );
78	mmeineke	377	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	mmeineke	420	double bigSigma;
96	mmeineke	377
97			};
98
99			class TraPPEFF : public ForceFields{
100
101			public:
102			TraPPEFF();
103			virtual ~TraPPEFF();
104	mmeineke	420
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	mmeineke	377
116			};
117
118
119			class DipoleTestFF : public ForceFields{
120
121			public:
122			DipoleTestFF();
123			virtual ~DipoleTestFF();
124
125	mmeineke	420	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	mmeineke	377	};
136
137			class TraPPE_ExFF : public ForceFields{
138
139			public:
140			TraPPE_ExFF();
141			virtual ~TraPPE_ExFF();
142
143	mmeineke	420	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	mmeineke	377	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	mmeineke	420	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	mmeineke	377	private:
177
178			void fastForward( char* stopText, char* searchOwner );
179	mmeineke	420
180	mmeineke	377	};
181
182			#endif
183