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