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 "fForceField.h"
#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 initForceField( int ljMixRule ) = 0;
  virtual void doForces( int calcPot, int calcStress );

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

protected:
  
  void initFortran( int ljMixPolicy, int useReactionField );
  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 initForceField( int ljMixRule ) {}
  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 initForceField( int ljMixRule ) {}
  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 initForceField( int ljMixRule );
  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 initForceField( int ljMixRule );
  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 );
};

#endif

Revision:	362
Committed:	Tue Mar 18 21:25:45 2003 UTC (21 years, 5 months ago) by mmeineke
File size:	2887 byte(s)
Log Message:	shed implementation of the Fortran interfaces.
#	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	357	#include "fForceField.h"
19	mmeineke	294	#include <fortranWrapDefines.hpp>
20
21	mmeineke	270	class bond_pair{
22			public:
23			bond_pair(){}
24			~bond_pair(){}
25
26			int a;
27			int b;
28			};
29
30			class bend_set{
31			public:
32	mmeineke	308	bend_set(){ isGhost = 0; }
33	mmeineke	270	~bend_set(){}
34
35	mmeineke	308	int ghost;
36			int isGhost;
37
38	mmeineke	270	int a;
39			int b;
40			int c;
41			};
42
43			class torsion_set{
44			public:
45			torsion_set(){}
46			~torsion_set(){}
47
48			int a;
49			int b;
50			int c;
51			int d;
52			};
53
54
55
56			class ForceFields{
57
58			public:
59			ForceFields(){ frcFile = NULL; entry_plug = NULL; }
60			virtual ~ForceFields(){}
61
62			void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
63			virtual void initializeAtoms( void ) = 0;
64			virtual void initializeBonds( bond_pair* the_bonds ) = 0;
65			virtual void initializeBends( bend_set* the_bends ) = 0;
66			virtual void initializeTorsions( torsion_set* the_torsions ) = 0;
67	mmeineke	362	virtual void initForceField( int ljMixRule ) = 0;
68			virtual void doForces( int calcPot, int calcStress );
69	mmeineke	270
70	mmeineke	294	void setFortranForceLoop( void (*fsub) doForceLoopList ){
71			fortranForceLoop = fsub;
72			}
73
74	mmeineke	270	protected:
75
76	mmeineke	359	void initFortran( int ljMixPolicy, int useReactionField );
77	mmeineke	294	void (*fortranForceLoop) doForceLoopList;
78
79	mmeineke	270	FILE *frcFile;
80			SimInfo* entry_plug;
81
82			int lineNum;
83			char readLine[500];
84			char* eof_test;
85
86			};
87
88			class TraPPEFF : public ForceFields{
89
90			public:
91			TraPPEFF();
92			virtual ~TraPPEFF();
93
94			void initializeAtoms( void );
95	mmeineke	362	void initForceField( int ljMixRule ) {}
96	mmeineke	270	void initializeBonds( bond_pair* the_bonds );
97			void initializeBends( bend_set* the_bends );
98			void initializeTorsions( torsion_set* the_torsions );
99			};
100
101
102			class DipoleTestFF : public ForceFields{
103
104			public:
105			DipoleTestFF();
106			virtual ~DipoleTestFF();
107
108			void initializeAtoms( void );
109	mmeineke	362	void initForceField( int ljMixRule ) {}
110	mmeineke	270	void initializeBonds( bond_pair* the_bonds );
111			void initializeBends( bend_set* the_bends );
112			void initializeTorsions( torsion_set* the_torsions );
113			};
114
115			class TraPPE_ExFF : public ForceFields{
116
117			public:
118			TraPPE_ExFF();
119			virtual ~TraPPE_ExFF();
120
121			void initializeAtoms( void );
122	mmeineke	362	void initForceField( int ljMixRule );
123	mmeineke	270	void initializeBonds( bond_pair* the_bonds );
124			void initializeBends( bend_set* the_bends );
125			void initializeTorsions( torsion_set* the_torsions );
126	mmeineke	291
127			private:
128
129			void fastForward( char* stopText, char* searchOwner );
130	mmeineke	270	};
131
132			class LJ_FF : public ForceFields{
133
134			public:
135			LJ_FF();
136			virtual ~LJ_FF();
137
138			void initializeAtoms( void );
139	mmeineke	362	void initForceField( int ljMixRule );
140	mmeineke	270	void initializeBonds( bond_pair* the_bonds );
141			void initializeBends( bend_set* the_bends );
142			void initializeTorsions( torsion_set* the_torsions );
143	mmeineke	294
144	mmeineke	270	private:
145
146			void fastForward( char* stopText, char* searchOwner );
147			};
148
149	mmeineke	345	#endif
150	mmeineke	287