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 420 by mmeineke, Thu Mar 27 17:32:03 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  
# Line 90 | Line 101 | class TraPPEFF : public ForceFields{ (public)
101   public:
102    TraPPEFF();
103    virtual ~TraPPEFF();
104 +
105 +  void readParams(){}
106 +  void cleanMe( void ){}
107 +
108 +  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
109 +  void initializeBonds( int nBonds, Bond** bondArray,
110 +                        bond_pair* the_bonds ) {}
111 +  void initializeBends( int nBends, Bend** bendArray,
112 +                        bend_set* the_bends ) {}
113 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
114 +                           torsion_set* the_torsions ) {}
115    
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 );
116   };
117  
118  
# Line 105 | Line 122 | class DipoleTestFF : public ForceFields{ (public)
122    DipoleTestFF();
123    virtual ~DipoleTestFF();
124    
125 <  void initializeAtoms( void );
126 <  void initForceField( int ljMixRule ) {}
127 <  void initializeBonds( bond_pair* the_bonds );
128 <  void initializeBends( bend_set* the_bends );
129 <  void initializeTorsions( torsion_set* the_torsions );
125 >  void readParams(){}
126 >  void cleanMe( void ){}
127 >
128 >  void initializeAtoms( int nAtoms, Atom** atomArray ) {}
129 >  void initializeBonds( int nBonds, Bond** bondArray,
130 >                        bond_pair* the_bonds ) {}
131 >  void initializeBends( int nBends, Bend** bendArray,
132 >                        bend_set* the_bends ) {}
133 >  void initializeTorsions( int nTorsions, Torsion** torsionArray,
134 >                           torsion_set* the_torsions ) {}
135   };
136  
137   class TraPPE_ExFF : public ForceFields{
# Line 117 | Line 139 | class TraPPE_ExFF : public ForceFields{ (public)
139   public:
140    TraPPE_ExFF();
141    virtual ~TraPPE_ExFF();
120 –  
121 –  void initializeAtoms( void );
122 –  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 );
142  
143 +  void readParams();
144 +  void cleanMe( void );
145 +
146 +  void initializeAtoms( int nAtoms, Atom** atomArray );
147 +  void initializeBonds( int nBonds, Bond** bondArray,
148 +                        bond_pair* the_bonds );
149 +  void initializeBends( int nBends, Bend** bendArray,
150 +                        bend_set* the_bends );
151 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
152 +                           torsion_set* the_torsions );
153 +
154   private:
155    
156    void fastForward( char* stopText, char* searchOwner );
# Line 135 | Line 162 | class LJ_FF : public ForceFields{ (public)
162    LJ_FF();
163    virtual ~LJ_FF();
164    
138 –  void initializeAtoms( void );
139 –  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 );
165  
166 +  void readParams();
167 +  void cleanMe( void );
168 +
169 +  void initializeAtoms( int nAtoms, Atom** atomArray );
170 +  void initializeBonds( int nBonds, Bond** bondArray,
171 +                        bond_pair* the_bonds );
172 +  void initializeBends( int nBends, Bend** bendArray,
173 +                        bend_set* the_bends );
174 +  void initializeTorsions( int nTorsions, Torsion** torsionArray,
175 +                           torsion_set* the_torsions );
176   private:
177  
178    void fastForward( char* stopText, char* searchOwner );
179 +
180   };
181  
182   #endif

Diff Legend

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