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

Comparing trunk/OOPSE-4/src/UseTheForce/ForceFields.hpp (file contents):
Revision 1646 by chrisfen, Tue Oct 26 18:02:46 2004 UTC vs.
Revision 1670 by gezelter, Thu Oct 28 16:56:20 2004 UTC

# Line 4 | Line 4
4   #define MK_STR(s) # s
5   #define STR_DEFINE(t, s) t = MK_STR(s)
6  
7 –
7   #include <stdio.h>
8   #include <stdlib.h>
9   #include <math.h>
10 + #include <string>
11 + #include <map>
12  
13   #include "primitives/Atom.hpp"
14   #include "brains/SimInfo.hpp"
15   #include "primitives/StuntDouble.hpp"
16 + #include "types/ShapeAtomType.hpp"
17 + #include "io/basic_ifstrstream.hpp"
18  
19   #ifdef IS_MPI
20   #include "UseTheForce/mpiForceField.h"
21   #endif
22  
23 + using namespace std;
24 + using namespace oopse;
25 +
26   class bond_pair{
27   public:
28    bond_pair(){}
# Line 55 | Line 61 | class ForceFields{ (public)
61   class ForceFields{
62  
63   public:
64 <  ForceFields(){ frcFile = NULL; entry_plug = NULL; has_variant=0;}
65 <  ForceFields(char * theVariant ){ frcFile = NULL; entry_plug = NULL; has_variant=1; strcpy(variant, theVariant); }
64 >  ForceFields(){
65 >
66 >    char* force_param_path;
67 >    frcFile = NULL;
68 >    entry_plug = NULL;
69 >    has_variant=0;
70 >
71 >    force_param_path = getenv("FORCE_PARAM_PATH");
72 >    if (force_param_path != NULL) {
73 >      ffPath = force_param_path;
74 >    } else {
75 >      ffPath = "";
76 >    }
77 >
78 >    if( ffPath.empty() ) {
79 >      STR_DEFINE(ffPath, FRC_PATH );
80 >    }  
81 >  }
82 >  ForceFields(const string &theVariant){
83 >    char* force_param_path;
84 >    frcFile = NULL;
85 >    entry_plug = NULL;
86 >    has_variant=1;
87 >    variant = theVariant;
88 >
89 >    force_param_path = getenv("FORCE_PARAM_PATH");
90 >    if (force_param_path != NULL) {
91 >      ffPath = force_param_path;
92 >    } else {
93 >      ffPath = "";
94 >    }
95 >
96 >    if( ffPath.empty() ) {
97 >      STR_DEFINE(ffPath, FRC_PATH );
98 >    }  
99 >  }
100    virtual ~ForceFields(){}
101    
102    void setSimInfo( SimInfo* the_entry_plug ) { entry_plug = the_entry_plug; }
# Line 81 | Line 121 | class ForceFields{ (public)
121    virtual void setRcut( double LJrcut );
122    virtual void doForces( int calcPot, int calcStress );
123  
84 –  virtual double getAtomTypeMass(char* atomType) = 0;
85 –
86 –
124   protected:
125    
126    void initFortran( int useReactionField );
127    
91 –
128    FILE *frcFile;
129    SimInfo* entry_plug;
130    
131    int lineNum;
132    char readLine[500];
133    char* eof_test;
98 –  char variant[100];
134    short int has_variant;
135    double bigSigma;
136  
137 +  string ffPath;
138 +  ifstrstream forceFile;
139 +  bool hasVariant;
140 +  string variant;
141 +  map<string, AtomType*> atomTypeMap;
142 +  // map<pair<string,string>, BondType*> bondTypeMap;
143 +  // map<tuple3<string,string,string>, BendType*> bendTypeMap;
144 +  // map<tuple4<string,string,string,string>, TorsionType*> torsionTypeMap;
145 +
146   };
147  
148  
# Line 120 | Line 164 | class DUFF : public ForceFields{ (public)
164                             torsion_set* the_torsions );
165  
166    void initForceField();
123 –  double getAtomTypeMass(char* atomType);
167  
168   private:
169    
# Line 146 | Line 189 | class LJFF : public ForceFields{ (public)
189                             torsion_set* the_torsions );
190  
191    void initForceField( );
149 –  double getAtomTypeMass(char* atomType);
192  
193 +
194   private:
195  
196    void fastForward( char* stopText, char* searchOwner );
# Line 157 | Line 200 | class EAM_FF : public ForceFields{ (public)
200   class EAM_FF : public ForceFields{
201  
202   public:
203 +
204    EAM_FF();
205 <  EAM_FF(char* the_variant);
205 >  EAM_FF(const string &theVariant);
206 >
207    virtual ~EAM_FF();
208    
164 –
209    void readParams();
210    void cleanMe( void );
211  
# Line 176 | Line 220 | class EAM_FF : public ForceFields{ (public)
220    void initForceField();
221  
222    void calcRcut( void );
223 <  double getAtomTypeMass(char* atomType);
223 >
224   private:
225  
226    void fastForward( char* stopText, char* searchOwner );
# Line 200 | Line 244 | class WATER : public ForceFields{ (public)
244    void initializeTorsions( int nTorsions, Torsion** torsionArray,
245                             torsion_set* the_torsions );
246    void initForceField();
203 –  double getAtomTypeMass(char* atomType);
247  
248 +
249   private:
250    
251    void fastForward( char* stopText, char* searchOwner );
# Line 212 | Line 256 | class Shapes_FF : public ForceFields{ (public)
256   class Shapes_FF : public ForceFields{
257  
258   public:
259 <  Shapes_FF();
260 <  Shapes_FF(char* the_variant);
259 >  Shapes_FF() : ForceFields() {};
260 >  Shapes_FF(const string &the_variant) : ForceFields(the_variant) {};
261    virtual ~Shapes_FF();
262    
263 <  void readForceFile();
263 >  void readParams();
264    void cleanMe( void );
265  
266    void initializeAtoms( int nAtoms, Atom** atomArray );
# Line 229 | Line 273 | class Shapes_FF : public ForceFields{ (public)
273  
274    void initForceField();
275  
276 +  void parseShapeFile(string shapeFileName, ShapeAtomType* st);
277 +
278    void calcRcut( void );
233 –  double getAtomTypeMass(char* atomType);
279  
280   private:
281 <  char* ffPath_env;
281 >
282 >  double findLargestContactDistance(ShapeAtomType* st);
283    double shapesRcut;
284  
285   };

Diff Legend

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