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

Comparing:
branches/mmeineke/OOPSE/libmdtools/ForceFields.hpp (file contents), Revision 377 by mmeineke, Fri Mar 21 17:42:12 2003 UTC vs.
trunk/OOPSE/libmdtools/ForceFields.hpp (file contents), 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 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 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 82 | Line 93 | class ForceFields{ (public)
93    int lineNum;
94    char readLine[500];
95    char* eof_test;
96 +  double bigSigma;
97  
98   };
99  
88 – class TraPPEFF : public ForceFields{
100  
101 + class DUFF : public ForceFields{
102 +
103   public:
104 <  TraPPEFF();
105 <  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 < };
104 >  DUFF();
105 >  virtual ~DUFF();
106  
107 +  void readParams();
108 +  void cleanMe( void );
109  
110 < class DipoleTestFF : public ForceFields{
110 >  void initializeAtoms( int nAtoms, Atom** atomArray );
111 >  void initializeBonds( int nBonds, Bond** bondArray,
112 >                        bond_pair* the_bonds );
113 >  void initializeBends( int nBends, Bend** bendArray,
114 >                        bend_set* the_bends );
115 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
116 >                           torsion_set* the_torsions );
117  
118 < public:
119 <  DipoleTestFF();
120 <  virtual ~DipoleTestFF();
118 >  void initForceField( int ljMixRule );
119 >
120 > private:
121    
122 <  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 );
122 >  void fastForward( char* stopText, char* searchOwner );
123   };
124  
125 < class TraPPE_ExFF : public ForceFields{
125 > class LJFF : public ForceFields{
126  
127   public:
128 <  TraPPE_ExFF();
129 <  virtual ~TraPPE_ExFF();
128 >  LJFF();
129 >  virtual ~LJFF();
130    
131 <  void initializeAtoms( void );
131 >
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 );
138 >  void initializeBends( int nBends, Bend** bendArray,
139 >                        bend_set* the_bends );
140 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
141 >                           torsion_set* the_torsions );
142 >
143    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 );
144  
145   private:
146 <  
146 >
147    void fastForward( char* stopText, char* searchOwner );
148 +
149   };
150  
151 < class LJ_FF : public ForceFields{
151 > class EAM_FF : public ForceFields{
152  
153   public:
154 <  LJ_FF();
155 <  virtual ~LJ_FF();
154 >  EAM_FF();
155 >  virtual ~EAM_FF();
156    
157 <  void initializeAtoms( void );
157 >
158 >  void readParams();
159 >  void cleanMe( void );
160 >
161 >  void initializeAtoms( int nAtoms, Atom** atomArray );
162 >  void initializeBonds( int nBonds, Bond** bondArray,
163 >                        bond_pair* the_bonds );
164 >  void initializeBends( int nBends, Bend** bendArray,
165 >                        bend_set* the_bends );
166 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
167 >                           torsion_set* the_torsions );
168 >
169    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 );
170  
171 +  void calcRcut( void );
172   private:
173  
174    void fastForward( char* stopText, char* searchOwner );
175 +  
176 +  double eamRcut;
177   };
178  
179 + class WATER : public ForceFields{
180 +
181 + public:
182 +  WATER();
183 +  virtual ~WATER();
184 +
185 +  void readParams();
186 +  void cleanMe( void );
187 +  void initializeAtoms( int nAtoms, Atom** atomArray );
188 +  void initializeBonds( int nBonds, Bond** bondArray,
189 +                        bond_pair* the_bonds );
190 +  void initializeBends( int nBends, Bend** bendArray,
191 +                        bend_set* the_bends );
192 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
193 +                           torsion_set* the_torsions );
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 +
203   #endif
204  

Diff Legend

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