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(){}
  ~bend_set(){}

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

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

protected:
  
  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 );
  void doForces( int ) {}
};


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 );
  void doForces( int ) {}
};

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 );
  void doForces( int );

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

};

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

  void doForces( int );

private:

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

  void initFortran( void );
};

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