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 420 by mmeineke, Thu Mar 27 17:32:03 2003 UTC vs.
Revision 1180 by chrisfen, Thu May 20 20:24:07 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 > #include <math.h>
11  
12   #include "Atom.hpp"
13   #include "SimInfo.hpp"
14 + #include "StuntDouble.hpp"
15  
16   #ifdef IS_MPI
17   #include "mpiForceField.h"
# Line 73 | Line 75 | class ForceFields{ (public)
75    virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
76                                     torsion_set* the_torsions ) = 0;
77    virtual void initForceField( int ljMixRule ) = 0;
78 +  virtual void initRestraints();
79 +  virtual void dumpzAngle();
80  
81    virtual void calcRcut( void );
82 +  virtual void setRcut( double LJrcut );
83    virtual void doForces( int calcPot, int calcStress );
84  
85 <  void setFortranForceLoop( void (*fsub) doForceLoopList ){
85 >  void setFortranForceLoop( doForceLoop_TD fsub ){
86      fortranForceLoop = fsub;
87    }
88  
89   protected:
90    
91    void initFortran( int ljMixPolicy, int useReactionField );
92 <  void (*fortranForceLoop) doForceLoopList;
92 >  doForceLoop_TD fortranForceLoop;
93  
94    FILE *frcFile;
95    SimInfo* entry_plug;
# Line 94 | Line 99 | class ForceFields{ (public)
99    char* eof_test;
100    double bigSigma;
101  
102 +  vector<StuntDouble*> myStunts;
103 +
104   };
105  
99 – class TraPPEFF : public ForceFields{
106  
107 + class DUFF : public ForceFields{
108 +
109   public:
110 <  TraPPEFF();
111 <  virtual ~TraPPEFF();
110 >  DUFF();
111 >  virtual ~DUFF();
112  
113 <  void readParams(){}
114 <  void cleanMe( void ){}
113 >  void readParams();
114 >  void cleanMe( void );
115  
116 <  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
116 >  void initializeAtoms( int nAtoms, Atom** atomArray );
117    void initializeBonds( int nBonds, Bond** bondArray,
118 <                        bond_pair* the_bonds ) {}
118 >                        bond_pair* the_bonds );
119    void initializeBends( int nBends, Bend** bendArray,
120 <                        bend_set* the_bends ) {}
120 >                        bend_set* the_bends );
121    void initializeTorsions( int nTorsions, Torsion** torsionArray,
122 <                           torsion_set* the_torsions ) {}
122 >                           torsion_set* the_torsions );
123 >
124 >  void initForceField( int ljMixRule );
125 >
126 > private:
127    
128 +  void fastForward( char* stopText, char* searchOwner );
129   };
130  
131 + class LJFF : public ForceFields{
132  
119 – class DipoleTestFF : public ForceFields{
120 –
133   public:
134 <  DipoleTestFF();
135 <  virtual ~DipoleTestFF();
134 >  LJFF();
135 >  virtual ~LJFF();
136    
125 –  void readParams(){}
126 –  void cleanMe( void ){}
137  
138 <  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
138 >  void readParams();
139 >  void cleanMe( void );
140 >
141 >  void initializeAtoms( int nAtoms, Atom** atomArray );
142    void initializeBonds( int nBonds, Bond** bondArray,
143 <                        bond_pair* the_bonds ) {}
143 >                        bond_pair* the_bonds );
144    void initializeBends( int nBends, Bend** bendArray,
145 <                        bend_set* the_bends ) {}
145 >                        bend_set* the_bends );
146    void initializeTorsions( int nTorsions, Torsion** torsionArray,
147 <                           torsion_set* the_torsions ) {}
147 >                           torsion_set* the_torsions );
148 >
149 >  void initForceField( int ljMixRule );
150 >
151 > private:
152 >
153 >  void fastForward( char* stopText, char* searchOwner );
154 >
155   };
156  
157 < class TraPPE_ExFF : public ForceFields{
157 > class EAM_FF : public ForceFields{
158  
159   public:
160 <  TraPPE_ExFF();
161 <  virtual ~TraPPE_ExFF();
160 >  EAM_FF();
161 >  virtual ~EAM_FF();
162 >  
163  
164    void readParams();
165    void cleanMe( void );
# Line 151 | Line 172 | class TraPPE_ExFF : public ForceFields{ (public)
172    void initializeTorsions( int nTorsions, Torsion** torsionArray,
173                             torsion_set* the_torsions );
174  
175 +  void initForceField( int ljMixRule );
176 +
177 +  void calcRcut( void );
178   private:
179 <  
179 >
180    void fastForward( char* stopText, char* searchOwner );
181 +  
182 +  double eamRcut;
183   };
184  
185 < class LJ_FF : public ForceFields{
185 > class WATER : public ForceFields{
186  
187   public:
188 <  LJ_FF();
189 <  virtual ~LJ_FF();
164 <  
188 >  WATER();
189 >  virtual ~WATER();
190  
191    void readParams();
192    void cleanMe( void );
168 –
193    void initializeAtoms( int nAtoms, Atom** atomArray );
194    void initializeBonds( int nBonds, Bond** bondArray,
195                          bond_pair* the_bonds );
# Line 173 | Line 197 | class LJ_FF : public ForceFields{ (public)
197                          bend_set* the_bends );
198    void initializeTorsions( int nTorsions, Torsion** torsionArray,
199                             torsion_set* the_torsions );
200 < private:
200 >  void initForceField( int ljMixRule );
201  
202 + private:
203 +  
204    void fastForward( char* stopText, char* searchOwner );
205 +  void sectionSearch( char* secHead, char* stopText, char* searchOwner );
206  
207   };
208  

Diff Legend

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