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 1261 by gezelter, Fri Jun 11 14:14:10 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 56 | Line 58 | class ForceFields{ (public)
58   class ForceFields{
59  
60   public:
61 <  ForceFields(){ frcFile = NULL; entry_plug = NULL; }
61 >  ForceFields(){ frcFile = NULL; entry_plug = NULL; has_variant=0;}
62 >  ForceFields(char * theVariant ){ frcFile = NULL; entry_plug = NULL; has_variant=1; strcpy(variant, theVariant); }
63    virtual ~ForceFields(){}
64    
65    void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
66 <  virtual void initializeAtoms( void ) = 0;
67 <  virtual void initializeBonds( bond_pair* the_bonds ) = 0;
68 <  virtual void initializeBends( bend_set* the_bends ) = 0;
69 <  virtual void initializeTorsions( torsion_set* the_torsions ) = 0;
66 >  
67 >  virtual void readParams( void ) = 0;
68 >  
69 >  virtual void cleanMe( void ) = 0;
70 >  
71 >
72 >  virtual void initializeAtoms( int nAtoms, Atom** atomArray ) = 0;
73 >  virtual void initializeBonds( int nBonds, Bond** bondArray,
74 >                                bond_pair* the_bonds ) = 0;
75 >  virtual void initializeBends( int nBends, Bend** bendArray,
76 >                                bend_set* the_bends ) = 0;
77 >  virtual void initializeTorsions( int nTorsions, Torsion** torsionArray,
78 >                                   torsion_set* the_torsions ) = 0;
79    virtual void initForceField( int ljMixRule ) = 0;
80 +  virtual void initRestraints();
81 +  virtual void dumpzAngle();
82 +
83 +  virtual void calcRcut( void );
84 +  virtual void setRcut( double LJrcut );
85    virtual void doForces( int calcPot, int calcStress );
86  
87 <  void setFortranForceLoop( void (*fsub) doForceLoopList ){
87 >  void setFortranForceLoop( doForceLoop_TD fsub ){
88      fortranForceLoop = fsub;
89    }
90  
91   protected:
92    
93    void initFortran( int ljMixPolicy, int useReactionField );
94 <  void (*fortranForceLoop) doForceLoopList;
94 >  doForceLoop_TD fortranForceLoop;
95  
96    FILE *frcFile;
97    SimInfo* entry_plug;
# Line 82 | Line 99 | class ForceFields{ (public)
99    int lineNum;
100    char readLine[500];
101    char* eof_test;
102 +  char variant[100];
103 +  short int has_variant;
104 +  double bigSigma;
105  
106   };
107  
88 – class TraPPEFF : public ForceFields{
108  
109 + class DUFF : public ForceFields{
110 +
111   public:
112 <  TraPPEFF();
113 <  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 < };
112 >  DUFF();
113 >  virtual ~DUFF();
114  
115 +  void readParams();
116 +  void cleanMe( void );
117  
118 < class DipoleTestFF : public ForceFields{
118 >  void initializeAtoms( int nAtoms, Atom** atomArray );
119 >  void initializeBonds( int nBonds, Bond** bondArray,
120 >                        bond_pair* the_bonds );
121 >  void initializeBends( int nBends, Bend** bendArray,
122 >                        bend_set* the_bends );
123 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
124 >                           torsion_set* the_torsions );
125  
126 < public:
127 <  DipoleTestFF();
128 <  virtual ~DipoleTestFF();
126 >  void initForceField( int ljMixRule );
127 >
128 > private:
129    
130 <  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 );
130 >  void fastForward( char* stopText, char* searchOwner );
131   };
132  
133 < class TraPPE_ExFF : public ForceFields{
133 > class LJFF : public ForceFields{
134  
135   public:
136 <  TraPPE_ExFF();
137 <  virtual ~TraPPE_ExFF();
136 >  LJFF();
137 >  virtual ~LJFF();
138    
139 <  void initializeAtoms( void );
139 >
140 >  void readParams();
141 >  void cleanMe( void );
142 >
143 >  void initializeAtoms( int nAtoms, Atom** atomArray );
144 >  void initializeBonds( int nBonds, Bond** bondArray,
145 >                        bond_pair* the_bonds );
146 >  void initializeBends( int nBends, Bend** bendArray,
147 >                        bend_set* the_bends );
148 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
149 >                           torsion_set* the_torsions );
150 >
151    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 );
152  
153   private:
154 <  
154 >
155    void fastForward( char* stopText, char* searchOwner );
156 +
157   };
158  
159 < class LJ_FF : public ForceFields{
159 > class EAM_FF : public ForceFields{
160  
161   public:
162 <  LJ_FF();
163 <  virtual ~LJ_FF();
162 >  EAM_FF();
163 >  EAM_FF(char* the_variant);
164 >  virtual ~EAM_FF();
165    
166 <  void initializeAtoms( void );
166 >
167 >  void readParams();
168 >  void cleanMe( void );
169 >
170 >  void initializeAtoms( int nAtoms, Atom** atomArray );
171 >  void initializeBonds( int nBonds, Bond** bondArray,
172 >                        bond_pair* the_bonds );
173 >  void initializeBends( int nBends, Bend** bendArray,
174 >                        bend_set* the_bends );
175 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
176 >                           torsion_set* the_torsions );
177 >
178    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 );
179  
180 +  void calcRcut( void );
181   private:
182  
183    void fastForward( char* stopText, char* searchOwner );
184 +  
185 +  double eamRcut;
186   };
187  
188 + class WATER : public ForceFields{
189 +
190 + public:
191 +  WATER();
192 +  virtual ~WATER();
193 +
194 +  void readParams();
195 +  void cleanMe( void );
196 +  void initializeAtoms( int nAtoms, Atom** atomArray );
197 +  void initializeBonds( int nBonds, Bond** bondArray,
198 +                        bond_pair* the_bonds );
199 +  void initializeBends( int nBends, Bend** bendArray,
200 +                        bend_set* the_bends );
201 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
202 +                           torsion_set* the_torsions );
203 +  void initForceField( int ljMixRule );
204 +
205 + private:
206 +  
207 +  void fastForward( char* stopText, char* searchOwner );
208 +  void sectionSearch( char* secHead, char* stopText, char* searchOwner );
209 +
210 + };
211 +
212   #endif
213  

Diff Legend

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