ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/ForceFields.hpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/ForceFields.hpp (file contents):
Revision 378 by mmeineke, Fri Mar 21 17:42:12 2003 UTC vs.
Revision 999 by chrisfen, Fri Jan 30 15:01:09 2004 UTC

# Line 5 | Line 5
5   #define STR_DEFINE(t, s) t = MK_STR(s)
6  
7  
8 < #include <cstdio>
9 < #include <cstdlib>
8 > #include <stdio.h>
9 > #include <stdlib.h>
10  
11   #include "Atom.hpp"
12   #include "SimInfo.hpp"
# Line 60 | Line 60 | class ForceFields{ (public)
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;
63 >  
64 >  virtual void readParams( void ) = 0;
65 >  virtual void cleanMe( void ) = 0;
66 >  
67 >
68 >  virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
69 >  virtual void initializeBonds( int nBonds, Bond** bondArray,
70 >                                bond_pair* the_bonds ) = 0;
71 >  virtual void initializeBends( int nBends, Bend** bendArray,
72 >                                bend_set* the_bends ) = 0;
73 >  virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
74 >                                   torsion_set* the_torsions ) = 0;
75    virtual void initForceField( int ljMixRule ) = 0;
76 +
77 +  virtual void calcRcut( void );
78    virtual void doForces( int calcPot, int calcStress );
79  
80 <  void setFortranForceLoop( void (*fsub) doForceLoopList ){
80 >  void setFortranForceLoop( doForceLoop_TD fsub ){
81      fortranForceLoop = fsub;
82    }
83  
84   protected:
85    
86    void initFortran( int ljMixPolicy, int useReactionField );
87 <  void (*fortranForceLoop) doForceLoopList;
87 >  doForceLoop_TD fortranForceLoop;
88  
89    FILE *frcFile;
90    SimInfo* entry_plug;
# Line 82 | Line 92 | class ForceFields{ (public)
92    int lineNum;
93    char readLine[500];
94    char* eof_test;
95 +  double bigSigma;
96  
97   };
98  
88 – class TraPPEFF : public ForceFields{
99  
100 + class DUFF : public ForceFields{
101 +
102   public:
103 <  TraPPEFF();
104 <  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 < };
103 >  DUFF();
104 >  virtual ~DUFF();
105  
106 +  void readParams();
107 +  void cleanMe( void );
108  
109 < class DipoleTestFF : public ForceFields{
109 >  void initializeAtoms( int nAtoms, Atom** atomArray );
110 >  void initializeBonds( int nBonds, Bond** bondArray,
111 >                        bond_pair* the_bonds );
112 >  void initializeBends( int nBends, Bend** bendArray,
113 >                        bend_set* the_bends );
114 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
115 >                           torsion_set* the_torsions );
116  
117 < public:
118 <  DipoleTestFF();
119 <  virtual ~DipoleTestFF();
117 >  void initForceField( int ljMixRule );
118 >
119 > private:
120    
121 <  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 );
121 >  void fastForward( char* stopText, char* searchOwner );
122   };
123  
124 < class TraPPE_ExFF : public ForceFields{
124 > class LJFF : public ForceFields{
125  
126   public:
127 <  TraPPE_ExFF();
128 <  virtual ~TraPPE_ExFF();
127 >  LJFF();
128 >  virtual ~LJFF();
129    
130 <  void initializeAtoms( void );
130 >
131 >  void readParams();
132 >  void cleanMe( void );
133 >
134 >  void initializeAtoms( int nAtoms, Atom** atomArray );
135 >  void initializeBonds( int nBonds, Bond** bondArray,
136 >                        bond_pair* the_bonds );
137 >  void initializeBends( int nBends, Bend** bendArray,
138 >                        bend_set* the_bends );
139 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
140 >                           torsion_set* the_torsions );
141 >
142    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 );
143  
144   private:
145 <  
145 >
146    void fastForward( char* stopText, char* searchOwner );
147 +
148   };
149  
150 < class LJ_FF : public ForceFields{
150 > class EAM_FF : public ForceFields{
151  
152   public:
153 <  LJ_FF();
154 <  virtual ~LJ_FF();
153 >  EAM_FF();
154 >  virtual ~EAM_FF();
155    
156 <  void initializeAtoms( void );
156 >
157 >  void readParams();
158 >  void cleanMe( void );
159 >
160 >  void initializeAtoms( int nAtoms, Atom** atomArray );
161 >  void initializeBonds( int nBonds, Bond** bondArray,
162 >                        bond_pair* the_bonds );
163 >  void initializeBends( int nBends, Bend** bendArray,
164 >                        bend_set* the_bends );
165 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
166 >                           torsion_set* the_torsions );
167 >
168    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 );
169  
170 +  void calcRcut( void );
171   private:
172  
173    void fastForward( char* stopText, char* searchOwner );
174 +  
175 +  double eamRcut;
176   };
177  
178 + class WATER : public ForceFields{
179 +
180 + public:
181 +  WATER();
182 +  virtual ~WATER();
183 +
184 +  void readParams();
185 +  void cleanMe( void );
186 +  void initializeAtoms( int nAtoms, Atom** atomArray );
187 +  void initializeBonds( int nBonds, Bond** bondArray,
188 +                        bond_pair* the_bonds );
189 +  void initializeBends( int nBends, Bend** bendArray,
190 +                        bend_set* the_bends );
191 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
192 +                           torsion_set* the_torsions );
193 +  void initForceField( int ljMixRule );
194 +
195 + private:
196 +  
197 +  void fastForward( char* stopText, char* searchOwner );
198 +  void sectionSearch( char* secHead, char* stopText, char* searchOwner );
199 +
200 + };
201 +
202   #endif
203  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines