mdtools/libmdCode/ForceFields.hpp

#ifndef __FORCEFIELDS_H__
#define __FORCEFIELDS_H__

#include <cstdio>
#include <cstdlib>

#include "Atom.hpp"
#include "SimInfo.hpp"

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

#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 initializeAtoms( void ) = 0;
  virtual void initializeBonds( bond_pair* the_bonds ) = 0;
  virtual void initializeBends( bend_set* the_bends ) = 0;
  virtual void initializeTorsions( torsion_set* the_torsions ) = 0;
  virtual void doForces( int calcPot );

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

protected:
  
  void initFortran( void );
  void (*fortranForceLoop) doForceLoopList;

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

};

class TraPPEFF : public ForceFields{

public:
  TraPPEFF();
  virtual ~TraPPEFF();
  
  void initializeAtoms( void );
  void initializeBonds( bond_pair* the_bonds );
  void initializeBends( bend_set* the_bends );
  void initializeTorsions( torsion_set* the_torsions );
};


class DipoleTestFF : public ForceFields{

public:
  DipoleTestFF();
  virtual ~DipoleTestFF();
  
  void initializeAtoms( void );
  void initializeBonds( bond_pair* the_bonds );
  void initializeBends( bend_set* the_bends );
  void initializeTorsions( torsion_set* the_torsions );
};

class TraPPE_ExFF : public ForceFields{

public:
  TraPPE_ExFF();
  virtual ~TraPPE_ExFF();
  
  void initializeAtoms( void );
  void initializeBonds( bond_pair* the_bonds );
  void initializeBends( bend_set* the_bends );
  void initializeTorsions( torsion_set* the_torsions );

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

class LJ_FF : public ForceFields{

public:
  LJ_FF();
  virtual ~LJ_FF();
  
  void initializeAtoms( void );
  void initializeBonds( bond_pair* the_bonds );
  void initializeBends( bend_set* the_bends );
  void initializeTorsions( torsion_set* the_torsions );

private:

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

// class SSD_FF : public ForceFields{

// public:
//   SSD_FF();
//   virtual ~SSD_FF();
  
//   void initializeAtoms( void );
//   void initializeBonds( bond_pair* the_bonds );
//   void initializeBends( bend_set* the_bends );
//   void initializeTorsions( torsion_set* the_torsions );
//   void setSSDfortran( void (*fortranSub)( double* positionArray,
//                                       double* forceArray,
//                                       double* potentialEnergy,
//                                       short int* doPotentialCalc ) ){
//     doSSDfortran = fortranSub;
//   }
//   void doForces( int );

// private:

//   void fastForward( char* stopText, char* searchOwner );
  
//   // set our sister fortran module's function to be our own.
//   void wrapMe( void );
//   void (*doSSDfortran)( double* positionArray,
//                      double* forceArray,
//                      double* potentialEnergy,
//                      short int* doPotentialCalc );
//   void initFortran( void );
// };

#endif
Revision:	308
Committed:	Mon Mar 10 21:44:31 2003 UTC (21 years, 5 months ago) by mmeineke
File size:	3408 byte(s)
Log Message:	Added ghostBend into SimSetup. only need to add awareness to TraPPE_Ex
#	User	Rev	Content
1	mmeineke	270	#ifndef __FORCEFIELDS_H__
2			#define __FORCEFIELDS_H__
3
4			#include <cstdio>
5			#include <cstdlib>
6
7			#include "Atom.hpp"
8			#include "SimInfo.hpp"
9
10			#ifdef IS_MPI
11			#include "mpiForceField.h"
12			#endif
13
14	mmeineke	294	#include <fortranWrapDefines.hpp>
15
16	mmeineke	270	class bond_pair{
17			public:
18			bond_pair(){}
19			~bond_pair(){}
20
21			int a;
22			int b;
23			};
24
25			class bend_set{
26			public:
27	mmeineke	308	bend_set(){ isGhost = 0; }
28	mmeineke	270	~bend_set(){}
29
30	mmeineke	308	int ghost;
31			int isGhost;
32
33	mmeineke	270	int a;
34			int b;
35			int c;
36			};
37
38			class torsion_set{
39			public:
40			torsion_set(){}
41			~torsion_set(){}
42
43			int a;
44			int b;
45			int c;
46			int d;
47			};
48
49
50
51			class ForceFields{
52
53			public:
54			ForceFields(){ frcFile = NULL; entry_plug = NULL; }
55			virtual ~ForceFields(){}
56
57			void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
58			virtual void initializeAtoms( void ) = 0;
59			virtual void initializeBonds( bond_pair* the_bonds ) = 0;
60			virtual void initializeBends( bend_set* the_bends ) = 0;
61			virtual void initializeTorsions( torsion_set* the_torsions ) = 0;
62	mmeineke	299	virtual void doForces( int calcPot );
63	mmeineke	270
64	mmeineke	294	void setFortranForceLoop( void (*fsub) doForceLoopList ){
65			fortranForceLoop = fsub;
66			}
67
68	mmeineke	270	protected:
69
70	mmeineke	299	void initFortran( void );
71	mmeineke	294	void (*fortranForceLoop) doForceLoopList;
72
73	mmeineke	270	FILE *frcFile;
74			SimInfo* entry_plug;
75
76			int lineNum;
77			char readLine[500];
78			char* eof_test;
79
80			};
81
82			class TraPPEFF : public ForceFields{
83
84			public:
85			TraPPEFF();
86			virtual ~TraPPEFF();
87
88			void initializeAtoms( void );
89			void initializeBonds( bond_pair* the_bonds );
90			void initializeBends( bend_set* the_bends );
91			void initializeTorsions( torsion_set* the_torsions );
92			};
93
94
95			class DipoleTestFF : public ForceFields{
96
97			public:
98			DipoleTestFF();
99			virtual ~DipoleTestFF();
100
101			void initializeAtoms( void );
102			void initializeBonds( bond_pair* the_bonds );
103			void initializeBends( bend_set* the_bends );
104			void initializeTorsions( torsion_set* the_torsions );
105			};
106
107			class TraPPE_ExFF : public ForceFields{
108
109			public:
110			TraPPE_ExFF();
111			virtual ~TraPPE_ExFF();
112
113			void initializeAtoms( void );
114			void initializeBonds( bond_pair* the_bonds );
115			void initializeBends( bend_set* the_bends );
116			void initializeTorsions( torsion_set* the_torsions );
117	mmeineke	291
118			private:
119
120			void fastForward( char* stopText, char* searchOwner );
121	mmeineke	270	};
122
123			class LJ_FF : public ForceFields{
124
125			public:
126			LJ_FF();
127			virtual ~LJ_FF();
128
129			void initializeAtoms( void );
130			void initializeBonds( bond_pair* the_bonds );
131			void initializeBends( bend_set* the_bends );
132			void initializeTorsions( torsion_set* the_torsions );
133	mmeineke	294
134	mmeineke	270	private:
135
136			void fastForward( char* stopText, char* searchOwner );
137			};
138
139	mmeineke	291	// class SSD_FF : public ForceFields{
140	mmeineke	287
141	mmeineke	291	// public:
142			// SSD_FF();
143			// virtual ~SSD_FF();
144	mmeineke	287
145	mmeineke	291	// void initializeAtoms( void );
146			// void initializeBonds( bond_pair* the_bonds );
147			// void initializeBends( bend_set* the_bends );
148			// void initializeTorsions( torsion_set* the_torsions );
149			// void setSSDfortran( void (fortranSub)( double positionArray,
150			// double* forceArray,
151			// double* potentialEnergy,
152			// short int* doPotentialCalc ) ){
153			// doSSDfortran = fortranSub;
154			// }
155			// void doForces( int );
156	mmeineke	287
157	mmeineke	291	// private:
158	mmeineke	287
159	mmeineke	291	// void fastForward( char* stopText, char* searchOwner );
160	mmeineke	287
161	mmeineke	291	// // set our sister fortran module's function to be our own.
162			// void wrapMe( void );
163			// void (doSSDfortran)( double positionArray,
164			// double* forceArray,
165			// double* potentialEnergy,
166			// short int* doPotentialCalc );
167			// void initFortran( void );
168			// };
169	mmeineke	287
170	mmeineke	270	#endif