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, 4 months ago) by mmeineke
File size:	3408 byte(s)
Log Message:	Added ghostBend into SimSetup. only need to add awareness to TraPPE_Ex
#	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(){ isGhost = 0; }
28	~bend_set(){}
29
30	int ghost;
31	int isGhost;
32
33	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	virtual void doForces( int calcPot );
63
64	void setFortranForceLoop( void (*fsub) doForceLoopList ){
65	fortranForceLoop = fsub;
66	}
67
68	protected:
69
70	void initFortran( void );
71	void (*fortranForceLoop) doForceLoopList;
72
73	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
118	private:
119
120	void fastForward( char* stopText, char* searchOwner );
121	};
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
134	private:
135
136	void fastForward( char* stopText, char* searchOwner );
137	};
138
139	// class SSD_FF : public ForceFields{
140
141	// public:
142	// SSD_FF();
143	// virtual ~SSD_FF();
144
145	// 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
157	// private:
158
159	// void fastForward( char* stopText, char* searchOwner );
160
161	// // 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
170	#endif