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 1187 by chrisfen, Sat May 22 18:16:18 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 60 | Line 62 | class ForceFields{ (public)
62    virtual ~ForceFields(){}
63    
64    void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
65 <  virtual void initializeAtoms( void ) = 0;
66 <  virtual void initializeBonds( bond_pair* the_bonds ) = 0;
67 <  virtual void initializeBends( bend_set* the_bends ) = 0;
68 <  virtual void initializeTorsions( torsion_set* the_torsions ) = 0;
65 >  
66 >  virtual void readParams( void ) = 0;
67 >  virtual void cleanMe( void ) = 0;
68 >  
69 >
70 >  virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
71 >  virtual void initializeBonds( int nBonds, Bond** bondArray,
72 >                                bond_pair* the_bonds ) = 0;
73 >  virtual void initializeBends( int nBends, Bend** bendArray,
74 >                                bend_set* the_bends ) = 0;
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 82 | Line 97 | class ForceFields{ (public)
97    int lineNum;
98    char readLine[500];
99    char* eof_test;
100 +  double bigSigma;
101  
102   };
103  
88 – class TraPPEFF : public ForceFields{
104  
105 + class DUFF : public ForceFields{
106 +
107   public:
108 <  TraPPEFF();
109 <  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 < };
108 >  DUFF();
109 >  virtual ~DUFF();
110  
111 +  void readParams();
112 +  void cleanMe( void );
113  
114 < class DipoleTestFF : public ForceFields{
114 >  void initializeAtoms( int nAtoms, Atom** atomArray );
115 >  void initializeBonds( int nBonds, Bond** bondArray,
116 >                        bond_pair* the_bonds );
117 >  void initializeBends( int nBends, Bend** bendArray,
118 >                        bend_set* the_bends );
119 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
120 >                           torsion_set* the_torsions );
121  
122 < public:
123 <  DipoleTestFF();
124 <  virtual ~DipoleTestFF();
122 >  void initForceField( int ljMixRule );
123 >
124 > private:
125    
126 <  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 );
126 >  void fastForward( char* stopText, char* searchOwner );
127   };
128  
129 < class TraPPE_ExFF : public ForceFields{
129 > class LJFF : public ForceFields{
130  
131   public:
132 <  TraPPE_ExFF();
133 <  virtual ~TraPPE_ExFF();
132 >  LJFF();
133 >  virtual ~LJFF();
134    
135 <  void initializeAtoms( void );
135 >
136 >  void readParams();
137 >  void cleanMe( void );
138 >
139 >  void initializeAtoms( int nAtoms, Atom** atomArray );
140 >  void initializeBonds( int nBonds, Bond** bondArray,
141 >                        bond_pair* the_bonds );
142 >  void initializeBends( int nBends, Bend** bendArray,
143 >                        bend_set* the_bends );
144 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
145 >                           torsion_set* the_torsions );
146 >
147    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 );
148  
149   private:
150 <  
150 >
151    void fastForward( char* stopText, char* searchOwner );
152 +
153   };
154  
155 < class LJ_FF : public ForceFields{
155 > class EAM_FF : public ForceFields{
156  
157   public:
158 <  LJ_FF();
159 <  virtual ~LJ_FF();
158 >  EAM_FF();
159 >  virtual ~EAM_FF();
160    
161 <  void initializeAtoms( void );
161 >
162 >  void readParams();
163 >  void cleanMe( void );
164 >
165 >  void initializeAtoms( int nAtoms, Atom** atomArray );
166 >  void initializeBonds( int nBonds, Bond** bondArray,
167 >                        bond_pair* the_bonds );
168 >  void initializeBends( int nBends, Bend** bendArray,
169 >                        bend_set* the_bends );
170 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
171 >                           torsion_set* the_torsions );
172 >
173    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 );
174  
175 +  void calcRcut( void );
176   private:
177  
178    void fastForward( char* stopText, char* searchOwner );
179 +  
180 +  double eamRcut;
181   };
182  
183 + class WATER : public ForceFields{
184 +
185 + public:
186 +  WATER();
187 +  virtual ~WATER();
188 +
189 +  void readParams();
190 +  void cleanMe( void );
191 +  void initializeAtoms( int nAtoms, Atom** atomArray );
192 +  void initializeBonds( int nBonds, Bond** bondArray,
193 +                        bond_pair* the_bonds );
194 +  void initializeBends( int nBends, Bend** bendArray,
195 +                        bend_set* the_bends );
196 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
197 +                           torsion_set* the_torsions );
198 +  void initForceField( int ljMixRule );
199 +
200 + private:
201 +  
202 +  void fastForward( char* stopText, char* searchOwner );
203 +  void sectionSearch( char* secHead, char* stopText, char* searchOwner );
204 +
205 + };
206 +
207   #endif
208  

Diff Legend

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