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

  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:	299
Committed:	Fri Mar 7 19:31:02 2003 UTC (21 years, 6 months ago) by mmeineke
File size:	3365 byte(s)
Log Message:	implemented the new fortran force interface
#	Content
1	#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	#include <fortranWrapDefines.hpp>
15
16	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 );
60
61	void setFortranForceLoop( void (*fsub) doForceLoopList ){
62	fortranForceLoop = fsub;
63	}
64
65	protected:
66
67	void initFortran( void );
68	void (*fortranForceLoop) doForceLoopList;
69
70	FILE *frcFile;
71	SimInfo* entry_plug;
72
73	int lineNum;
74	char readLine[500];
75	char* eof_test;
76
77	};
78
79	class TraPPEFF : public ForceFields{
80
81	public:
82	TraPPEFF();
83	virtual ~TraPPEFF();
84
85	void initializeAtoms( void );
86	void initializeBonds( bond_pair* the_bonds );
87	void initializeBends( bend_set* the_bends );
88	void initializeTorsions( torsion_set* the_torsions );
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	};
103
104	class TraPPE_ExFF : public ForceFields{
105
106	public:
107	TraPPE_ExFF();
108	virtual ~TraPPE_ExFF();
109
110	void initializeAtoms( void );
111	void initializeBonds( bond_pair* the_bonds );
112	void initializeBends( bend_set* the_bends );
113	void initializeTorsions( torsion_set* the_torsions );
114
115	private:
116
117	void fastForward( char* stopText, char* searchOwner );
118	};
119
120	class LJ_FF : public ForceFields{
121
122	public:
123	LJ_FF();
124	virtual ~LJ_FF();
125
126	void initializeAtoms( void );
127	void initializeBonds( bond_pair* the_bonds );
128	void initializeBends( bend_set* the_bends );
129	void initializeTorsions( torsion_set* the_torsions );
130
131	private:
132
133	void fastForward( char* stopText, char* searchOwner );
134	};
135
136	// class SSD_FF : public ForceFields{
137
138	// public:
139	// SSD_FF();
140	// virtual ~SSD_FF();
141
142	// void initializeAtoms( void );
143	// void initializeBonds( bond_pair* the_bonds );
144	// void initializeBends( bend_set* the_bends );
145	// void initializeTorsions( torsion_set* the_torsions );
146	// void setSSDfortran( void (fortranSub)( double positionArray,
147	// double* forceArray,
148	// double* potentialEnergy,
149	// short int* doPotentialCalc ) ){
150	// doSSDfortran = fortranSub;
151	// }
152	// void doForces( int );
153
154	// private:
155
156	// void fastForward( char* stopText, char* searchOwner );
157
158	// // set our sister fortran module's function to be our own.
159	// void wrapMe( void );
160	// void (doSSDfortran)( double positionArray,
161	// double* forceArray,
162	// double* potentialEnergy,
163	// short int* doPotentialCalc );
164	// void initFortran( void );
165	// };
166
167	#endif