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 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 77 | Line 77 | class ForceFields{ (public)
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 96 | Line 96 | class TraPPEFF : public ForceFields{
96  
97   };
98  
99 – class TraPPEFF : public ForceFields{
99  
100 + class DUFF : public ForceFields{
101 +
102   public:
103 <  TraPPEFF();
104 <  virtual ~TraPPEFF();
103 >  DUFF();
104 >  virtual ~DUFF();
105  
106 <  void readParams(){}
107 <  void cleanMe( void ){}
106 >  void readParams();
107 >  void cleanMe( void );
108  
109 <  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
109 >  void initializeAtoms( int nAtoms, Atom** atomArray );
110    void initializeBonds( int nBonds, Bond** bondArray,
111 <                        bond_pair* the_bonds ) {}
111 >                        bond_pair* the_bonds );
112    void initializeBends( int nBends, Bend** bendArray,
113 <                        bend_set* the_bends ) {}
113 >                        bend_set* the_bends );
114    void initializeTorsions( int nTorsions, Torsion** torsionArray,
115 <                           torsion_set* the_torsions ) {}
115 >                           torsion_set* the_torsions );
116 >
117 >  void initForceField( int ljMixRule );
118 >
119 > private:
120    
121 +  void fastForward( char* stopText, char* searchOwner );
122   };
123  
124 + class LJFF : public ForceFields{
125  
119 – class DipoleTestFF : public ForceFields{
120 –
126   public:
127 <  DipoleTestFF();
128 <  virtual ~DipoleTestFF();
127 >  LJFF();
128 >  virtual ~LJFF();
129    
125 –  void readParams(){}
126 –  void cleanMe( void ){}
130  
131 <  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
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 ) {}
136 >                        bond_pair* the_bonds );
137    void initializeBends( int nBends, Bend** bendArray,
138 <                        bend_set* the_bends ) {}
138 >                        bend_set* the_bends );
139    void initializeTorsions( int nTorsions, Torsion** torsionArray,
140 <                           torsion_set* the_torsions ) {}
140 >                           torsion_set* the_torsions );
141 >
142 >  void initForceField( int ljMixRule );
143 >
144 > private:
145 >
146 >  void fastForward( char* stopText, char* searchOwner );
147 >
148   };
149  
150 < class TraPPE_ExFF : public ForceFields{
150 > class EAM_FF : public ForceFields{
151  
152   public:
153 <  TraPPE_ExFF();
154 <  virtual ~TraPPE_ExFF();
153 >  EAM_FF();
154 >  virtual ~EAM_FF();
155 >  
156  
157    void readParams();
158    void cleanMe( void );
# Line 151 | Line 165 | class TraPPE_ExFF : public ForceFields{ (private)
165    void initializeTorsions( int nTorsions, Torsion** torsionArray,
166                             torsion_set* the_torsions );
167  
168 +  void initForceField( int ljMixRule );
169 +
170 +  void calcRcut( void );
171   private:
172 <  
172 >
173    void fastForward( char* stopText, char* searchOwner );
174 +  
175 +  double eamRcut;
176   };
177  
178 < class LJ_FF : public ForceFields{
178 > class WATER : public ForceFields{
179  
180   public:
181 <  LJ_FF();
182 <  virtual ~LJ_FF();
164 <  
181 >  WATER();
182 >  virtual ~WATER();
183  
184    void readParams();
185    void cleanMe( void );
168 –
186    void initializeAtoms( int nAtoms, Atom** atomArray );
187    void initializeBonds( int nBonds, Bond** bondArray,
188                          bond_pair* the_bonds );
# Line 173 | Line 190 | class LJ_FF : public ForceFields{ (private)
190                          bend_set* the_bends );
191    void initializeTorsions( int nTorsions, Torsion** torsionArray,
192                             torsion_set* the_torsions );
193 < private:
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  

Diff Legend

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