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 1275 by cli2, Fri Jul 4 20:54:29 2008 UTC vs.
Revision 1303 by cli2, Mon Oct 13 21:35:22 2008 UTC

# Line 133 | Line 133 | namespace oopse {
133          ii++;
134        }
135  
136 –      // sort the foundBonds by the score:
136  
137 <      std::sort(foundBonds.begin(), foundBonds.end());
138 <      
139 <      int bestScore = foundBonds[0].first;
140 <      std::vector<std::string> theKeys = foundBonds[0].second;
141 <
142 <      std::cout << "best matching bond = " << theKeys[0] << "\t" << theKeys[1]  << "\t(score = "<< bestScore << ")\n";      
143 <      BondType* bestType = bondTypeCont_.find(theKeys);
144 <      if (bestType)
145 <        return bestType;
146 <      else {
147 <        //if no exact match found, try wild card match
148 <        return bondTypeCont_.find(keys, wildCardAtomTypeName_);      
137 >      if (foundBonds.size() > 0) {
138 >        // sort the foundBonds by the score:
139 >        std::sort(foundBonds.begin(), foundBonds.end());
140 >    
141 >        int bestScore = foundBonds[0].first;
142 >        std::vector<std::string> theKeys = foundBonds[0].second;
143 >        
144 >        BondType* bestType = bondTypeCont_.find(theKeys);
145 >        
146 >        return bestType;
147 >      } else {
148 >        //if no exact match found, try wild card match
149 >        return bondTypeCont_.find(keys, wildCardAtomTypeName_);      
150        }
151      }
152    }
# Line 220 | Line 220 | namespace oopse {
220          jj++;
221        }
222        
223 <      std::sort(foundBends.begin(), foundBends.end());
224 <
225 <      int jscore = foundBends[0].first;
226 <      int ikscore = foundBends[0].second;
227 <      std::vector<std::string> theKeys = foundBends[0].third;
228 <
229 <      std::cout << "best matching bend = " << theKeys[0] << "\t" <<theKeys[1]  << "\t" << theKeys[2] << "\t(scores = "<< jscore << "\t" << ikscore << ")\n";      
230 <
231 <      BendType* bestType = bendTypeCont_.find(theKeys);  
232 <      if (bestType)
233 <        return bestType;
234 <      else {
235 <      
223 >      if (foundBends.size() > 0) {
224 >        std::sort(foundBends.begin(), foundBends.end());
225 >        int jscore = foundBends[0].first;
226 >        int ikscore = foundBends[0].second;
227 >        std::vector<std::string> theKeys = foundBends[0].third;      
228 >        
229 >        BendType* bestType = bendTypeCont_.find(theKeys);  
230 >        return bestType;
231 >      } else {        
232          //if no exact match found, try wild card match
233          return bendTypeCont_.find(keys, wildCardAtomTypeName_);      
234        }
235      }
236    }
237  
242 –
238    TorsionType* ForceField::getTorsionType(const std::string &at1,
239                                            const std::string &at2,
240                                            const std::string &at3,
# Line 327 | Line 322 | namespace oopse {
322          jj++;
323        }
324        
325 <      std::sort(foundTorsions.begin(), foundTorsions.end());
326 <
327 <      int jkscore = foundTorsions[0].first;
328 <      int ilscore = foundTorsions[0].second;
329 <      std::vector<std::string> theKeys = foundTorsions[0].third;
330 <
331 <      std::cout << "best matching torsion = " << theKeys[0] << "\t" <<theKeys[1]  << "\t" << theKeys[2] << "\t" << theKeys[3] << "\t(scores = "<< jkscore << "\t" << ilscore << ")\n";
332 <
338 <      
339 <      TorsionType* bestType = torsionTypeCont_.find(theKeys);
340 <      if (bestType) {
341 <        return bestType;
325 >      if (foundTorsions.size() > 0) {
326 >        std::sort(foundTorsions.begin(), foundTorsions.end());
327 >        int jkscore = foundTorsions[0].first;
328 >        int ilscore = foundTorsions[0].second;
329 >        std::vector<std::string> theKeys = foundTorsions[0].third;
330 >        
331 >        TorsionType* bestType = torsionTypeCont_.find(theKeys);
332 >        return bestType;
333        } else {
334          //if no exact match found, try wild card match
335          return torsionTypeCont_.find(keys, wildCardAtomTypeName_);
# Line 357 | Line 348 | namespace oopse {
348      keys.push_back(at4);    
349  
350      //try exact match first
351 <    InversionType* inversionType = inversionTypeCont_.find(keys);
351 >    InversionType* inversionType = inversionTypeCont_.permutedFindSkippingFirstElement(keys);
352      if (inversionType) {
353        return inversionType;
354      } else {
# Line 419 | Line 410 | namespace oopse {
410                myKeys.push_back((*k)->getName());
411                myKeys.push_back((*l)->getName());
412                
413 <              InversionType* inversionType = inversionTypeCont_.find(myKeys);
413 >              InversionType* inversionType = inversionTypeCont_.permutedFindSkippingFirstElement(myKeys);
414                if (inversionType) {
415                  foundInversions.push_back( make_tuple3(Iscore, JKLscore, myKeys) );
416                }
# Line 431 | Line 422 | namespace oopse {
422          }
423          jj++;
424        }
425 <      
426 <      std::sort(foundInversions.begin(), foundInversions.end());
427 <      
428 <      int iscore = foundInversions[0].first;
429 <      int jklscore = foundInversions[0].second;
430 <      std::vector<std::string> theKeys = foundInversions[0].third;
431 <      
432 <      std::cout << "best matching inversion = " << theKeys[0] << "\t" <<theKeys[1]  << "\t" << theKeys[2] << "\t" << theKeys[3] << "\t(scores = "<< iscore << "\t" << jklscore << ")\n";
433 <      
443 <      
444 <      InversionType* bestType = inversionTypeCont_.find(theKeys);
445 <      if (bestType) {
446 <        return bestType;
425 >        
426 >      if (foundInversions.size() > 0) {
427 >        std::sort(foundInversions.begin(), foundInversions.end());
428 >        int iscore = foundInversions[0].first;
429 >        int jklscore = foundInversions[0].second;
430 >        std::vector<std::string> theKeys = foundInversions[0].third;
431 >        
432 >        InversionType* bestType = inversionTypeCont_.permutedFindSkippingFirstElement(theKeys);
433 >        return bestType;
434        } else {
435          //if no exact match found, try wild card match
436          return inversionTypeCont_.find(keys, wildCardAtomTypeName_);
# Line 522 | Line 509 | namespace oopse {
509      return atomTypeCont_.add(keys, atomType);
510    }
511  
512 +  bool ForceField::replaceAtomType(const std::string &at, AtomType* atomType) {
513 +    std::vector<std::string> keys;
514 +    keys.push_back(at);
515 +    return atomTypeCont_.replace(keys, atomType);
516 +  }
517 +
518    bool ForceField::addBondType(const std::string &at1, const std::string &at2,
519                                 BondType* bondType) {
520      std::vector<std::string> keys;

Diff Legend

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