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 1097 by gezelter, Mon Apr 12 20:32:20 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 75 | Line 75 | class ForceFields{ (public)
75    virtual void initForceField( int ljMixRule ) = 0;
76  
77    virtual void calcRcut( void );
78 +  virtual void setRcut( double LJrcut );
79    virtual void doForces( int calcPot, int calcStress );
80  
81 <  void setFortranForceLoop( void (*fsub) doForceLoopList ){
81 >  void setFortranForceLoop( doForceLoop_TD fsub ){
82      fortranForceLoop = fsub;
83    }
84  
85   protected:
86    
87    void initFortran( int ljMixPolicy, int useReactionField );
88 <  void (*fortranForceLoop) doForceLoopList;
88 >  doForceLoop_TD fortranForceLoop;
89  
90    FILE *frcFile;
91    SimInfo* entry_plug;
# Line 96 | Line 97 | class TraPPEFF : public ForceFields{
97  
98   };
99  
99 – class TraPPEFF : public ForceFields{
100  
101 + class DUFF : public ForceFields{
102 +
103   public:
104 <  TraPPEFF();
105 <  virtual ~TraPPEFF();
104 >  DUFF();
105 >  virtual ~DUFF();
106  
107 <  void readParams(){}
108 <  void cleanMe( void ){}
107 >  void readParams();
108 >  void cleanMe( void );
109  
110 <  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
110 >  void initializeAtoms( int nAtoms, Atom** atomArray );
111    void initializeBonds( int nBonds, Bond** bondArray,
112 <                        bond_pair* the_bonds ) {}
112 >                        bond_pair* the_bonds );
113    void initializeBends( int nBends, Bend** bendArray,
114 <                        bend_set* the_bends ) {}
114 >                        bend_set* the_bends );
115    void initializeTorsions( int nTorsions, Torsion** torsionArray,
116 <                           torsion_set* the_torsions ) {}
116 >                           torsion_set* the_torsions );
117 >
118 >  void initForceField( int ljMixRule );
119 >
120 > private:
121    
122 +  void fastForward( char* stopText, char* searchOwner );
123   };
124  
125 + class LJFF : public ForceFields{
126  
119 – class DipoleTestFF : public ForceFields{
120 –
127   public:
128 <  DipoleTestFF();
129 <  virtual ~DipoleTestFF();
128 >  LJFF();
129 >  virtual ~LJFF();
130    
125 –  void readParams(){}
126 –  void cleanMe( void ){}
131  
132 <  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
132 >  void readParams();
133 >  void cleanMe( void );
134 >
135 >  void initializeAtoms( int nAtoms, Atom** atomArray );
136    void initializeBonds( int nBonds, Bond** bondArray,
137 <                        bond_pair* the_bonds ) {}
137 >                        bond_pair* the_bonds );
138    void initializeBends( int nBends, Bend** bendArray,
139 <                        bend_set* the_bends ) {}
139 >                        bend_set* the_bends );
140    void initializeTorsions( int nTorsions, Torsion** torsionArray,
141 <                           torsion_set* the_torsions ) {}
141 >                           torsion_set* the_torsions );
142 >
143 >  void initForceField( int ljMixRule );
144 >
145 > private:
146 >
147 >  void fastForward( char* stopText, char* searchOwner );
148 >
149   };
150  
151 < class TraPPE_ExFF : public ForceFields{
151 > class EAM_FF : public ForceFields{
152  
153   public:
154 <  TraPPE_ExFF();
155 <  virtual ~TraPPE_ExFF();
154 >  EAM_FF();
155 >  virtual ~EAM_FF();
156 >  
157  
158    void readParams();
159    void cleanMe( void );
# Line 151 | Line 166 | class TraPPE_ExFF : public ForceFields{ (private)
166    void initializeTorsions( int nTorsions, Torsion** torsionArray,
167                             torsion_set* the_torsions );
168  
169 +  void initForceField( int ljMixRule );
170 +
171 +  void calcRcut( void );
172   private:
173 <  
173 >
174    void fastForward( char* stopText, char* searchOwner );
175 +  
176 +  double eamRcut;
177   };
178  
179 < class LJ_FF : public ForceFields{
179 > class WATER : public ForceFields{
180  
181   public:
182 <  LJ_FF();
183 <  virtual ~LJ_FF();
164 <  
182 >  WATER();
183 >  virtual ~WATER();
184  
185    void readParams();
186    void cleanMe( void );
168 –
187    void initializeAtoms( int nAtoms, Atom** atomArray );
188    void initializeBonds( int nBonds, Bond** bondArray,
189                          bond_pair* the_bonds );
# Line 173 | Line 191 | class LJ_FF : public ForceFields{ (private)
191                          bend_set* the_bends );
192    void initializeTorsions( int nTorsions, Torsion** torsionArray,
193                             torsion_set* the_torsions );
194 < private:
194 >  void initForceField( int ljMixRule );
195  
196 + private:
197 +  
198    void fastForward( char* stopText, char* searchOwner );
199 +  void sectionSearch( char* secHead, char* stopText, char* searchOwner );
200  
201   };
202  

Diff Legend

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