OOPSE/libmdtools/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:	377
Committed:	Fri Mar 21 17:42:12 2003 UTC (22 years, 7 months ago) by mmeineke
Original Path:	*branches/mmeineke/OOPSE/libmdtools/ForceFields.hpp*
File size:	2887 byte(s)
Log Message:	New OOPSE Tree
#	Content
1	#ifndef __FORCEFIELDS_H__
2	#define __FORCEFIELDS_H__
3
4	#define MK_STR(s) # s
5	#define STR_DEFINE(t, s) t = MK_STR(s)
6
7
8	#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	#include "fForceField.h"
19	#include "fortranWrapDefines.hpp"
20
21	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	bend_set(){ isGhost = 0; }
33	~bend_set(){}
34
35	int ghost;
36	int isGhost;
37
38	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	virtual void initForceField( int ljMixRule ) = 0;
68	virtual void doForces( int calcPot, int calcStress );
69
70	void setFortranForceLoop( void (*fsub) doForceLoopList ){
71	fortranForceLoop = fsub;
72	}
73
74	protected:
75
76	void initFortran( int ljMixPolicy, int useReactionField );
77	void (*fortranForceLoop) doForceLoopList;
78
79	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	void initForceField( int ljMixRule ) {}
96	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	void initForceField( int ljMixRule ) {}
110	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	void initForceField( int ljMixRule );
123	void initializeBonds( bond_pair* the_bonds );
124	void initializeBends( bend_set* the_bends );
125	void initializeTorsions( torsion_set* the_torsions );
126
127	private:
128
129	void fastForward( char* stopText, char* searchOwner );
130	};
131
132	class LJ_FF : public ForceFields{
133
134	public:
135	LJ_FF();
136	virtual ~LJ_FF();
137
138	void initializeAtoms( void );
139	void initForceField( int ljMixRule );
140	void initializeBonds( bond_pair* the_bonds );
141	void initializeBends( bend_set* the_bends );
142	void initializeTorsions( torsion_set* the_torsions );
143
144	private:
145
146	void fastForward( char* stopText, char* searchOwner );
147	};
148
149	#endif
150