ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/brains/ForceField.cpp
(Generate patch)

Comparing trunk/src/UseTheForce/ForceField.cpp (file contents):
Revision 507 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 1195 by cpuglis, Thu Dec 6 20:04:02 2007 UTC

# Line 50 | Line 50
50   #include "UseTheForce/ForceField.hpp"
51   #include "utils/simError.h"
52   #include "UseTheForce/DarkSide/atype_interface.h"
53 + #include "UseTheForce/DarkSide/fForceOptions_interface.h"
54 + #include "UseTheForce/DarkSide/switcheroo_interface.h"
55   namespace oopse {
56  
57    ForceField::ForceField() {
# Line 67 | Line 69 | namespace oopse {
69  
70    ForceField::~ForceField() {
71      deleteAtypes();
72 +    deleteSwitch();
73    }
74  
75    AtomType* ForceField::getAtomType(const std::string &at) {
# Line 75 | Line 78 | namespace oopse {
78      return atomTypeCont_.find(keys);
79    }
80  
81 <  BondType* ForceField::getBondType(const std::string &at1, const std::string &at2) {
81 >  BondType* ForceField::getBondType(const std::string &at1,
82 >                                    const std::string &at2) {
83      std::vector<std::string> keys;
84      keys.push_back(at1);
85      keys.push_back(at2);    
# Line 88 | Line 92 | namespace oopse {
92        //if no exact match found, try wild card match
93        return bondTypeCont_.find(keys, wildCardAtomTypeName_);
94      }
91 –
95    }
96  
97 <  BendType* ForceField::getBendType(const std::string &at1, const std::string &at2,
97 >  BendType* ForceField::getBendType(const std::string &at1,
98 >                                    const std::string &at2,
99                                      const std::string &at3) {
100      std::vector<std::string> keys;
101      keys.push_back(at1);
# Line 108 | Line 112 | namespace oopse {
112      }
113    }
114  
115 <  TorsionType* ForceField::getTorsionType(const std::string &at1, const std::string &at2,
116 <                                          const std::string &at3, const std::string &at4) {
115 >  TorsionType* ForceField::getTorsionType(const std::string &at1,
116 >                                          const std::string &at2,
117 >                                          const std::string &at3,
118 >                                          const std::string &at4) {
119      std::vector<std::string> keys;
120      keys.push_back(at1);
121      keys.push_back(at2);    
# Line 125 | Line 131 | namespace oopse {
131      }
132      
133      return torsionTypeCont_.find(keys, wildCardAtomTypeName_);
128 –
134    }
135  
136 <  BondType* ForceField::getExactBondType(const std::string &at1, const std::string &at2){
136 >  NonBondedInteractionType* ForceField::getNonBondedInteractionType(const std::string &at1, const std::string &at2) {
137      std::vector<std::string> keys;
138      keys.push_back(at1);
139      keys.push_back(at2);    
140 +    
141 +    //try exact match first
142 +    NonBondedInteractionType* nbiType = nonBondedInteractionTypeCont_.find(keys);
143 +    if (nbiType) {
144 +      return nbiType;
145 +    } else {
146 +      //if no exact match found, try wild card match
147 +      return nonBondedInteractionTypeCont_.find(keys, wildCardAtomTypeName_);
148 +    }    
149 +  }
150 +  
151 +  BondType* ForceField::getExactBondType(const std::string &at1,
152 +                                         const std::string &at2){
153 +    std::vector<std::string> keys;
154 +    keys.push_back(at1);
155 +    keys.push_back(at2);    
156      return bondTypeCont_.find(keys);
157    }
158 <
159 <  BendType* ForceField::getExactBendType(const std::string &at1, const std::string &at2,
158 >  
159 >  BendType* ForceField::getExactBendType(const std::string &at1,
160 >                                         const std::string &at2,
161                                           const std::string &at3){
162      std::vector<std::string> keys;
163      keys.push_back(at1);
# Line 143 | Line 165 | namespace oopse {
165      keys.push_back(at3);    
166      return bendTypeCont_.find(keys);
167    }
168 <
169 <  TorsionType* ForceField::getExactTorsionType(const std::string &at1, const std::string &at2,
170 <                                               const std::string &at3, const std::string &at4){
168 >  
169 >  TorsionType* ForceField::getExactTorsionType(const std::string &at1,
170 >                                               const std::string &at2,
171 >                                               const std::string &at3,
172 >                                               const std::string &at4){
173      std::vector<std::string> keys;
174      keys.push_back(at1);
175      keys.push_back(at2);    
# Line 153 | Line 177 | namespace oopse {
177      keys.push_back(at4);  
178      return torsionTypeCont_.find(keys);
179    }
180 +
181 +  NonBondedInteractionType* ForceField::getExactNonBondedInteractionType(const std::string &at1, const std::string &at2){
182 +    std::vector<std::string> keys;
183 +    keys.push_back(at1);
184 +    keys.push_back(at2);    
185 +    return nonBondedInteractionTypeCont_.find(keys);
186 +  }
187 +
188 +
189    bool ForceField::addAtomType(const std::string &at, AtomType* atomType) {
190      std::vector<std::string> keys;
191      keys.push_back(at);
192      return atomTypeCont_.add(keys, atomType);
193    }
194  
195 <  bool ForceField::addBondType(const std::string &at1, const std::string &at2, BondType* bondType) {
195 >  bool ForceField::addBondType(const std::string &at1, const std::string &at2,
196 >                               BondType* bondType) {
197      std::vector<std::string> keys;
198      keys.push_back(at1);
199      keys.push_back(at2);    
200 <    return bondTypeCont_.add(keys, bondType);
167 <
200 >    return bondTypeCont_.add(keys, bondType);    
201    }
202 <
202 >  
203    bool ForceField::addBendType(const std::string &at1, const std::string &at2,
204                                 const std::string &at3, BendType* bendType) {
205      std::vector<std::string> keys;
# Line 175 | Line 208 | namespace oopse {
208      keys.push_back(at3);    
209      return bendTypeCont_.add(keys, bendType);
210    }
211 <
212 <  bool ForceField::addTorsionType(const std::string &at1, const std::string &at2,
213 <                                  const std::string &at3, const std::string &at4, TorsionType* torsionType) {
211 >  
212 >  bool ForceField::addTorsionType(const std::string &at1,
213 >                                  const std::string &at2,
214 >                                  const std::string &at3,
215 >                                  const std::string &at4,
216 >                                  TorsionType* torsionType) {
217      std::vector<std::string> keys;
218      keys.push_back(at1);
219      keys.push_back(at2);    
# Line 186 | Line 222 | namespace oopse {
222      return torsionTypeCont_.add(keys, torsionType);
223    }
224  
225 <  double ForceField::getRcutFromAtomType(AtomType* at) {
225 >  bool ForceField::addNonBondedInteractionType(const std::string &at1,
226 >                                               const std::string &at2,
227 >                                               NonBondedInteractionType* nbiType) {
228 >    std::vector<std::string> keys;
229 >    keys.push_back(at1);
230 >    keys.push_back(at2);    
231 >    return nonBondedInteractionTypeCont_.add(keys, nbiType);
232 >  }
233 >  
234 >  RealType ForceField::getRcutFromAtomType(AtomType* at) {
235      /**@todo */
236      GenericData* data;
237 <    double rcut = 0.0;
238 <
237 >    RealType rcut = 0.0;
238 >    
239      if (at->isLennardJones()) {
240        data = at->getPropertyByName("LennardJones");
241        if (data != NULL) {
242          LJParamGenericData* ljData = dynamic_cast<LJParamGenericData*>(data);
243 <
243 >        
244          if (ljData != NULL) {
245            LJParam ljParam = ljData->getData();
246 <
246 >          
247            //by default use 2.5*sigma as cutoff radius
248            rcut = 2.5 * ljParam.sigma;
249 <                
249 >          
250          } else {
251            sprintf( painCave.errMsg,
252                     "Can not cast GenericData to LJParam\n");
# Line 216 | Line 261 | namespace oopse {
261          simError();          
262        }
263      }
219 –
264      return rcut;    
265    }
266 +  
267  
223 –
268    ifstrstream* ForceField::openForceFieldFile(const std::string& filename) {
269      std::string forceFieldFilename(filename);
270      ifstrstream* ffStream = new ifstrstream();
# Line 247 | Line 291 | namespace oopse {
291          simError();
292        }
293      }  
250 –
294      return ffStream;
252 –
295    }
296  
297 +  void ForceField::setFortranForceOptions(){
298 +    ForceOptions theseFortranOptions;
299 +    forceFieldOptions_.makeFortranOptions(theseFortranOptions);
300 +    setfForceOptions(&theseFortranOptions);
301 +  }
302   } //end namespace oopse

Diff Legend

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