mdtools/headers/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

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

// typedef struct{
//   int a, b;
// } bond_pair;

// typedef struct{
//   int a, b, c;
// } bend_set;

// typedef struct{
//   int a, b, c, d;
// } torsion_set;


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;

protected:
  
  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 );
};

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

};

#endif
Revision:	225
Committed:	Wed Jan 8 21:54:20 2003 UTC (21 years, 6 months ago) by mmeineke
File size:	2341 byte(s)
Log Message:	fixed up LJ_FF
#	User	Rev	Content
1	mmeineke	10	#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	mmeineke	151	#ifdef IS_MPI
11			#include "mpiForceField.h"
12			#endif
13
14	mmeineke	10	class bond_pair{
15			public:
16			bond_pair(){}
17			~bond_pair(){}
18
19			int a;
20			int b;
21			};
22
23			class bend_set{
24			public:
25			bend_set(){}
26			~bend_set(){}
27
28			int a;
29			int b;
30			int c;
31			};
32
33			class torsion_set{
34			public:
35			torsion_set(){}
36			~torsion_set(){}
37
38			int a;
39			int b;
40			int c;
41			int d;
42			};
43
44			// typedef struct{
45			// int a, b;
46			// } bond_pair;
47
48			// typedef struct{
49			// int a, b, c;
50			// } bend_set;
51
52			// typedef struct{
53			// int a, b, c, d;
54			// } torsion_set;
55
56
57			class ForceFields{
58
59			public:
60			ForceFields(){ frcFile = NULL; entry_plug = NULL; }
61	mmeineke	117	virtual ~ForceFields(){}
62	mmeineke	10
63			void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
64			virtual void initializeAtoms( void ) = 0;
65			virtual void initializeBonds( bond_pair* the_bonds ) = 0;
66			virtual void initializeBends( bend_set* the_bends ) = 0;
67			virtual void initializeTorsions( torsion_set* the_torsions ) = 0;
68
69			protected:
70
71			FILE *frcFile;
72			SimInfo* entry_plug;
73	mmeineke	225
74			int lineNum;
75			char readLine[500];
76			char* eof_test;
77	mmeineke	10
78			};
79
80			class TraPPEFF : public ForceFields{
81
82			public:
83			TraPPEFF();
84	mmeineke	117	virtual ~TraPPEFF();
85	mmeineke	10
86			void initializeAtoms( void );
87			void initializeBonds( bond_pair* the_bonds );
88			void initializeBends( bend_set* the_bends );
89			void initializeTorsions( torsion_set* the_torsions );
90			};
91
92
93			class DipoleTestFF : public ForceFields{
94
95			public:
96			DipoleTestFF();
97	mmeineke	117	virtual ~DipoleTestFF();
98	mmeineke	10
99			void initializeAtoms( void );
100			void initializeBonds( bond_pair* the_bonds );
101			void initializeBends( bend_set* the_bends );
102			void initializeTorsions( torsion_set* the_torsions );
103			};
104
105			class TraPPE_ExFF : public ForceFields{
106
107			public:
108			TraPPE_ExFF();
109	mmeineke	117	virtual ~TraPPE_ExFF();
110	mmeineke	10
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			};
116
117	chuckv	215	class LJ_FF : public ForceFields{
118
119			public:
120			LJ_FF();
121			virtual ~LJ_FF();
122
123			void initializeAtoms( void );
124			void initializeBonds( bond_pair* the_bonds );
125			void initializeBends( bend_set* the_bends );
126			void initializeTorsions( torsion_set* the_torsions );
127	mmeineke	225
128			private:
129
130			void fastForward( char* stopText, char* searchOwner );
131
132	chuckv	215	};
133
134	mmeineke	10	#endif