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 378 by mmeineke, Fri Mar 21 17:42:12 2003 UTC vs.
Revision 500 by chuckv, Tue Apr 15 20:40:04 2003 UTC

# 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 doForces( int calcPot, int calcStress );
79  
80    void setFortranForceLoop( void (*fsub) doForceLoopList ){
# Line 82 | Line 92 | class ForceFields{ (public)
92    int lineNum;
93    char readLine[500];
94    char* eof_test;
95 +  double bigSigma;
96  
97   };
98  
88 – class TraPPEFF : public ForceFields{
99  
90 – public:
91 –  TraPPEFF();
92 –  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 – };
100 –
101 –
102 – class DipoleTestFF : public ForceFields{
103 –
104 – public:
105 –  DipoleTestFF();
106 –  virtual ~DipoleTestFF();
107 –  
108 –  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 );
113 – };
114 –
100   class TraPPE_ExFF : public ForceFields{
101  
102   public:
103    TraPPE_ExFF();
104    virtual ~TraPPE_ExFF();
105 <  
106 <  void initializeAtoms( void );
105 >
106 >  void readParams();
107 >  void cleanMe( void );
108 >
109 >  void initializeAtoms( int nAtoms, Atom** atomArray );
110 >  void initializeBonds( int nBonds, Bond** bondArray,
111 >                        bond_pair* the_bonds );
112 >  void initializeBends( int nBends, Bend** bendArray,
113 >                        bend_set* the_bends );
114 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
115 >                           torsion_set* the_torsions );
116 >
117    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 );
118  
119   private:
120    
# Line 135 | Line 127 | class LJ_FF : public ForceFields{ (public)
127    LJ_FF();
128    virtual ~LJ_FF();
129    
130 <  void initializeAtoms( void );
130 >
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 );
137 >  void initializeBends( int nBends, Bend** bendArray,
138 >                        bend_set* the_bends );
139 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
140 >                           torsion_set* the_torsions );
141 >
142    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 );
143  
144   private:
145  
146    void fastForward( char* stopText, char* searchOwner );
147 +
148   };
149 + class EAM_FF : public ForceFields{
150  
151 + public:
152 +  EAM_FF();
153 +  virtual ~EAM_FF();
154 +  
155 +
156 +  void readParams();
157 +  void cleanMe( void );
158 +
159 +  void initializeAtoms( int nAtoms, Atom** atomArray );
160 +  void initializeBonds( int nBonds, Bond** bondArray,
161 +                        bond_pair* the_bonds );
162 +  void initializeBends( int nBends, Bend** bendArray,
163 +                        bend_set* the_bends );
164 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
165 +                           torsion_set* the_torsions );
166 +
167 +  void initForceField( int ljMixRule );
168 +
169 + private:
170 +
171 +  void fastForward( char* stopText, char* searchOwner );
172 +
173 + };
174 +
175   #endif
176  

Diff Legend

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