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

Comparing trunk/src/nonbonded/InteractionManager.cpp (file contents):
Revision 1925 by gezelter, Wed Aug 7 15:24:16 2013 UTC vs.
Revision 2033 by gezelter, Sat Nov 1 14:12:16 2014 UTC

# Line 90 | Line 90 | namespace OpenMD {
90  
91      ForceField::AtomTypeContainer* atomTypes = forceField_->getAtomTypes();
92      int nTypes = atomTypes->size();
93 +    sHash_.resize(nTypes);
94      iHash_.resize(nTypes);
95      interactions_.resize(nTypes);
96      ForceField::AtomTypeContainer::MapTypeIterator i1, i2;
# Line 97 | Line 98 | namespace OpenMD {
98      AtomType* atype2;
99      int atid1, atid2;
100  
101 <    // We only need to worry about the types that are actually in the simulation:
102 <
101 >    // We only need to worry about the types that are actually in the
102 >    // simulation:
103 >    
104      set<AtomType*> atypes = info_->getSimulatedAtomTypes();
105  
106      lj_->setSimulatedAtomTypes(atypes);
# Line 115 | Line 117 | namespace OpenMD {
117      set<AtomType*>::iterator at;
118  
119      for (at = atypes.begin(); at != atypes.end(); ++at) {
120 <    
119 <      //for (atype1 = atomTypes->beginType(i1); atype1 != NULL;
120 <      //   atype1 = atomTypes->nextType(i1)) {
121 <      
120 >          
121        atype1 = *at;
122        atid1 = atype1->getIdent();
123        iHash_[atid1].resize(nTypes);
# Line 135 | Line 134 | namespace OpenMD {
134          painCave.isFatal = 0;
135          simError();                
136        }
137 +          
138 +      if (atype1->isLennardJones()) {
139 +        sHash_[atid1] |= LJ_INTERACTION;
140 +      }
141 +      if (atype1->isElectrostatic()) {
142 +        sHash_[atid1] |= ELECTROSTATIC_INTERACTION;
143 +      }
144 +      if (atype1->isSticky()) {
145 +        sHash_[atid1] |= STICKY_INTERACTION;
146 +      }
147 +      if (atype1->isStickyPower()) {
148 +        sHash_[atid1] |= STICKY_INTERACTION;
149 +      }
150 +      if (atype1->isEAM()) {      
151 +        sHash_[atid1] |= EAM_INTERACTION;
152 +      }
153 +      if (atype1->isSC()) {
154 +        sHash_[atid1] |= SC_INTERACTION;
155 +      }
156 +      if (atype1->isGayBerne()) {
157 +        sHash_[atid1] |= GB_INTERACTION;
158 +      }
159      }
139 –    
160      // Now, iterate over all known types and add to the interaction map:
161      
162      map<int, AtomType*>::iterator it1, it2;
# Line 152 | Line 172 | namespace OpenMD {
172          
173          if (atype1->isLennardJones() && atype2->isLennardJones()) {
174            interactions_[atid1][atid2].insert(lj_);
175 <          iHash_[atid1][atid2] |= LJ_PAIR;
175 >          iHash_[atid1][atid2] |= LJ_INTERACTION;
176          }
177          if (atype1->isElectrostatic() && atype2->isElectrostatic() ) {
178            interactions_[atid1][atid2].insert(electrostatic_);
179 <          iHash_[atid1][atid2] |= ELECTROSTATIC_PAIR;
179 >          iHash_[atid1][atid2] |= ELECTROSTATIC_INTERACTION;
180          }
181          if (atype1->isSticky() && atype2->isSticky() ) {
182            interactions_[atid1][atid2].insert(sticky_);
183 <          iHash_[atid1][atid2] |= STICKY_PAIR;
183 >          iHash_[atid1][atid2] |= STICKY_INTERACTION;
184          }
185          if (atype1->isStickyPower() && atype2->isStickyPower() ) {
186            interactions_[atid1][atid2].insert(sticky_);
187 <          iHash_[atid1][atid2] |= STICKY_PAIR;
187 >          iHash_[atid1][atid2] |= STICKY_INTERACTION;
188          }
189          if (atype1->isEAM() && atype2->isEAM() ) {
190            interactions_[atid1][atid2].insert(eam_);
191 <          iHash_[atid1][atid2] |= EAM_PAIR;
191 >          iHash_[atid1][atid2] |= EAM_INTERACTION;
192          }
193          if (atype1->isSC() && atype2->isSC() ) {
194            interactions_[atid1][atid2].insert(sc_);
195 <          iHash_[atid1][atid2] |= SC_PAIR;
195 >          iHash_[atid1][atid2] |= SC_INTERACTION;
196          }
197          if (atype1->isGayBerne() && atype2->isGayBerne() ) {
198            interactions_[atid1][atid2].insert(gb_);
199 <          iHash_[atid1][atid2] |= GB_PAIR;
199 >          iHash_[atid1][atid2] |= GB_INTERACTION;
200          }
201          if ((atype1->isGayBerne() && atype2->isLennardJones())
202              || (atype1->isLennardJones() && atype2->isGayBerne())) {
203            interactions_[atid1][atid2].insert(gb_);
204 <          iHash_[atid1][atid2] |= GB_PAIR;
204 >          iHash_[atid1][atid2] |= GB_INTERACTION;
205          }
206          
207          // look for an explicitly-set non-bonded interaction type using the
# Line 207 | Line 227 | namespace OpenMD {
227                }
228              }
229              interactions_[atid1][atid2].insert(lj_);
230 <            iHash_[atid1][atid2] |= LJ_PAIR;
230 >            iHash_[atid1][atid2] |= LJ_INTERACTION;
231              vdwExplicit = true;
232            }
233            
# Line 234 | Line 254 | namespace OpenMD {
254                }
255              }
256              interactions_[atid1][atid2].insert(morse_);
257 <            iHash_[atid1][atid2] |= MORSE_PAIR;
257 >            iHash_[atid1][atid2] |= MORSE_INTERACTION;
258              vdwExplicit = true;
259            }
260  
# Line 261 | Line 281 | namespace OpenMD {
281                }
282              }
283              interactions_[atid1][atid2].insert(repulsivePower_);
284 <            iHash_[atid1][atid2] |= REPULSIVEPOWER_PAIR;
284 >            iHash_[atid1][atid2] |= REPULSIVEPOWER_INTERACTION;
285              vdwExplicit = true;
286            }
287            
# Line 279 | Line 299 | namespace OpenMD {
299                }
300              }
301              interactions_[atid1][atid2].insert(eam_);
302 <            iHash_[atid1][atid2] |= EAM_PAIR;
302 >            iHash_[atid1][atid2] |= EAM_INTERACTION;
303              metExplicit = true;
304            }
305            
# Line 306 | Line 326 | namespace OpenMD {
326                }
327              }
328              interactions_[atid1][atid2].insert(sc_);
329 <            iHash_[atid1][atid2] |= SC_PAIR;
329 >            iHash_[atid1][atid2] |= SC_INTERACTION;
330              metExplicit = true;
331            }
332            
# Line 333 | Line 353 | namespace OpenMD {
353                }
354              }
355              interactions_[atid1][atid2].insert(maw_);
356 <            iHash_[atid1][atid2] |= MAW_PAIR;
356 >            iHash_[atid1][atid2] |= MAW_INTERACTION;
357              vdwExplicit = true;
358            }        
359          }
# Line 352 | Line 372 | namespace OpenMD {
372        atid1 = atype1->getIdent();
373        for (jt = it; jt != simTypes.end(); ++jt) {
374          atype2 = (*jt);
375 <        atid1 = atype1->getIdent();
375 >        atid2 = atype2->getIdent();
376          
377          if (interactions_[atid1][atid2].size() == 0) {
378            sprintf( painCave.errMsg,
# Line 385 | Line 405 | namespace OpenMD {
405  
406      int& iHash = iHash_[idat.atid1][idat.atid2];
407  
408 <    if ((iHash & EAM_PAIR) != 0) eam_->calcDensity(idat);
409 <    if ((iHash & SC_PAIR) != 0)  sc_->calcDensity(idat);
408 >    if ((iHash & EAM_INTERACTION) != 0) eam_->calcDensity(idat);
409 >    if ((iHash & SC_INTERACTION) != 0)  sc_->calcDensity(idat);
410  
411      // set<NonBondedInteraction*>::iterator it;
412  
# Line 404 | Line 424 | namespace OpenMD {
424  
425      if (!initialized_) initialize();
426      
427 <    int& iHash = iHash_[sdat.atid][sdat.atid];
427 >    int& sHash = sHash_[sdat.atid];
428  
429 <    if ((iHash & EAM_PAIR) != 0) eam_->calcFunctional(sdat);
430 <    if ((iHash & SC_PAIR) != 0)  sc_->calcFunctional(sdat);
429 >    if ((sHash & EAM_INTERACTION) != 0)  eam_->calcFunctional(sdat);
430 >    if ((sHash & SC_INTERACTION) != 0)  sc_->calcFunctional(sdat);
431  
432      // set<NonBondedInteraction*>::iterator it;
433      
# Line 426 | Line 446 | namespace OpenMD {
446  
447      int& iHash = iHash_[idat.atid1][idat.atid2];
448  
449 <    if ((iHash & ELECTROSTATIC_PAIR) != 0) electrostatic_->calcForce(idat);
449 >    if ((iHash & ELECTROSTATIC_INTERACTION) != 0) electrostatic_->calcForce(idat);
450        
451      // electrostatics still has to worry about indirect
452      // contributions from excluded pairs of atoms, but nothing else does:
453  
454      if (idat.excluded) return;
455  
456 <    if ((iHash & LJ_PAIR) != 0)             lj_->calcForce(idat);
457 <    if ((iHash & GB_PAIR) != 0)             gb_->calcForce(idat);
458 <    if ((iHash & STICKY_PAIR) != 0)         sticky_->calcForce(idat);
459 <    if ((iHash & MORSE_PAIR) != 0)          morse_->calcForce(idat);
460 <    if ((iHash & REPULSIVEPOWER_PAIR) != 0) repulsivePower_->calcForce(idat);
461 <    if ((iHash & EAM_PAIR) != 0)            eam_->calcForce(idat);
462 <    if ((iHash & SC_PAIR) != 0)             sc_->calcForce(idat);
463 <    if ((iHash & MAW_PAIR) != 0)            maw_->calcForce(idat);
456 >    if ((iHash & LJ_INTERACTION) != 0)             lj_->calcForce(idat);
457 >    if ((iHash & GB_INTERACTION) != 0)             gb_->calcForce(idat);
458 >    if ((iHash & STICKY_INTERACTION) != 0)         sticky_->calcForce(idat);
459 >    if ((iHash & MORSE_INTERACTION) != 0)          morse_->calcForce(idat);
460 >    if ((iHash & REPULSIVEPOWER_INTERACTION) != 0) repulsivePower_->calcForce(idat);
461 >    if ((iHash & EAM_INTERACTION) != 0)            eam_->calcForce(idat);
462 >    if ((iHash & SC_INTERACTION) != 0)             sc_->calcForce(idat);
463 >    if ((iHash & MAW_INTERACTION) != 0)            maw_->calcForce(idat);
464  
465      // set<NonBondedInteraction*>::iterator it;
466  
# Line 462 | Line 482 | namespace OpenMD {
482  
483      if (!initialized_) initialize();
484      
485 <    int& iHash = iHash_[sdat.atid][sdat.atid];
485 >    int& sHash = sHash_[sdat.atid];
486  
487 <    if ((iHash & ELECTROSTATIC_PAIR) != 0) electrostatic_->calcSelfCorrection(sdat);
487 >    if ((sHash & ELECTROSTATIC_INTERACTION) != 0) electrostatic_->calcSelfCorrection(sdat);
488  
489      // set<NonBondedInteraction*>::iterator it;
490  
# Line 493 | Line 513 | namespace OpenMD {
513      for (it = interactions_[*atid][*atid].begin();
514           it != interactions_[*atid][*atid].end();
515           ++it)
516 <      cutoff = max(cutoff, (*it)->getSuggestedCutoffRadius(make_pair(atype, atype)));  
516 >      cutoff = max(cutoff, (*it)->getSuggestedCutoffRadius(make_pair(atype,
517 >                                                                     atype)));
518      return cutoff;    
519    }
520  
# Line 507 | Line 528 | namespace OpenMD {
528      
529      for (it = interactions_[atid][atid].begin();
530           it != interactions_[atid][atid].end(); ++it)
531 <      cutoff = max(cutoff, (*it)->getSuggestedCutoffRadius(make_pair(atype, atype)));  
531 >      cutoff = max(cutoff, (*it)->getSuggestedCutoffRadius(make_pair(atype,
532 >                                                                     atype)));
533      return cutoff;    
534    }
535   } //end namespace OpenMD

Diff Legend

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