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 1879 by gezelter, Sun Jun 16 15:15:42 2013 UTC vs.
Revision 2033 by gezelter, Sat Nov 1 14:12:16 2014 UTC

# Line 89 | Line 89 | namespace OpenMD {
89      repulsivePower_->setForceField(forceField_);
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;
97      AtomType* atype1;
98      AtomType* atype2;
99 <    pair<AtomType*, AtomType*> key;
99 >    int atid1, atid2;
100 >
101 >    // We only need to worry about the types that are actually in the
102 >    // simulation:
103      
104 <    for (atype1 = atomTypes->beginType(i1); atype1 != NULL;
105 <         atype1 = atomTypes->nextType(i1)) {
106 <      
107 <      // add it to the map:
108 <      
104 >    set<AtomType*> atypes = info_->getSimulatedAtomTypes();
105 >
106 >    lj_->setSimulatedAtomTypes(atypes);
107 >    gb_->setSimulatedAtomTypes(atypes);
108 >    sticky_->setSimulatedAtomTypes(atypes);
109 >    eam_->setSimulatedAtomTypes(atypes);
110 >    sc_->setSimulatedAtomTypes(atypes);
111 >    morse_->setSimulatedAtomTypes(atypes);
112 >    electrostatic_->setSimInfo(info_);
113 >    electrostatic_->setSimulatedAtomTypes(atypes);
114 >    maw_->setSimulatedAtomTypes(atypes);
115 >    repulsivePower_->setSimulatedAtomTypes(atypes);
116 >
117 >    set<AtomType*>::iterator at;
118 >
119 >    for (at = atypes.begin(); at != atypes.end(); ++at) {
120 >          
121 >      atype1 = *at;
122 >      atid1 = atype1->getIdent();
123 >      iHash_[atid1].resize(nTypes);
124 >      interactions_[atid1].resize(nTypes);
125 >
126 >      // add it to the map:      
127        pair<map<int,AtomType*>::iterator,bool> ret;    
128 <      ret = typeMap_.insert( pair<int, AtomType*>(atype1->getIdent(), atype1) );
128 >      ret = typeMap_.insert( pair<int, AtomType*>(atid1, atype1) );
129        if (ret.second == false) {
130          sprintf( painCave.errMsg,
131                   "InteractionManager already had a previous entry with ident %d\n",
# Line 109 | 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      }
113 –    
160      // Now, iterate over all known types and add to the interaction map:
161      
162      map<int, AtomType*>::iterator it1, it2;
163      for (it1 = typeMap_.begin(); it1 != typeMap_.end(); ++it1) {
164        atype1 = (*it1).second;
165 +      atid1 = atype1->getIdent();
166  
167        for( it2 = typeMap_.begin(); it2 != typeMap_.end(); ++it2) {        
168          atype2 = (*it2).second;
169 +        atid2 = atype2->getIdent();
170                                
171 <        key = make_pair(atype1, atype2);
124 <
125 <        iHash_[key] = 0;
171 >        iHash_[atid1][atid2] = 0;
172          
173          if (atype1->isLennardJones() && atype2->isLennardJones()) {
174 <          interactions_[key].insert(lj_);
175 <          iHash_[key] |= LJ_PAIR;
174 >          interactions_[atid1][atid2].insert(lj_);
175 >          iHash_[atid1][atid2] |= LJ_INTERACTION;
176          }
177          if (atype1->isElectrostatic() && atype2->isElectrostatic() ) {
178 <          interactions_[key].insert(electrostatic_);
179 <          iHash_[key] |= ELECTROSTATIC_PAIR;
178 >          interactions_[atid1][atid2].insert(electrostatic_);
179 >          iHash_[atid1][atid2] |= ELECTROSTATIC_INTERACTION;
180          }
181          if (atype1->isSticky() && atype2->isSticky() ) {
182 <          interactions_[key].insert(sticky_);
183 <          iHash_[key] |= STICKY_PAIR;
182 >          interactions_[atid1][atid2].insert(sticky_);
183 >          iHash_[atid1][atid2] |= STICKY_INTERACTION;
184          }
185          if (atype1->isStickyPower() && atype2->isStickyPower() ) {
186 <          interactions_[key].insert(sticky_);
187 <          iHash_[key] |= STICKY_PAIR;
186 >          interactions_[atid1][atid2].insert(sticky_);
187 >          iHash_[atid1][atid2] |= STICKY_INTERACTION;
188          }
189          if (atype1->isEAM() && atype2->isEAM() ) {
190 <          interactions_[key].insert(eam_);
191 <          iHash_[key] |= EAM_PAIR;
190 >          interactions_[atid1][atid2].insert(eam_);
191 >          iHash_[atid1][atid2] |= EAM_INTERACTION;
192          }
193          if (atype1->isSC() && atype2->isSC() ) {
194 <          interactions_[key].insert(sc_);
195 <          iHash_[key] |= SC_PAIR;
194 >          interactions_[atid1][atid2].insert(sc_);
195 >          iHash_[atid1][atid2] |= SC_INTERACTION;
196          }
197          if (atype1->isGayBerne() && atype2->isGayBerne() ) {
198 <          interactions_[key].insert(gb_);
199 <          iHash_[key] |= GB_PAIR;
198 >          interactions_[atid1][atid2].insert(gb_);
199 >          iHash_[atid1][atid2] |= GB_INTERACTION;
200          }
201          if ((atype1->isGayBerne() && atype2->isLennardJones())
202              || (atype1->isLennardJones() && atype2->isGayBerne())) {
203 <          interactions_[key].insert(gb_);
204 <          iHash_[key] |= GB_PAIR;
203 >          interactions_[atid1][atid2].insert(gb_);
204 >          iHash_[atid1][atid2] |= GB_INTERACTION;
205          }
206          
207          // look for an explicitly-set non-bonded interaction type using the
# Line 172 | Line 218 | namespace OpenMD {
218              // We found an explicit Lennard-Jones interaction.  
219              // override all other vdw entries for this pair of atom types:
220              set<NonBondedInteraction*>::iterator it;
221 <            for (it = interactions_[key].begin();
222 <                 it != interactions_[key].end(); ++it) {
221 >            for (it = interactions_[atid1][atid2].begin();
222 >                 it != interactions_[atid1][atid2].end(); ++it) {
223                InteractionFamily ifam = (*it)->getFamily();
224                if (ifam == VANDERWAALS_FAMILY) {
225 <                interactions_[key].erase(*it);
226 <                // work on iHash here;
225 >                interactions_[atid1][atid2].erase(*it);
226 >                iHash_[atid1][atid2] ^= (*it)->getHash();
227                }
228              }
229 <            interactions_[key].insert(lj_);
230 <            iHash_[key] |= LJ_PAIR;
229 >            interactions_[atid1][atid2].insert(lj_);
230 >            iHash_[atid1][atid2] |= LJ_INTERACTION;
231              vdwExplicit = true;
232            }
233            
# Line 199 | Line 245 | namespace OpenMD {
245              // We found an explicit Morse interaction.  
246              // override all other vdw entries for this pair of atom types:
247              set<NonBondedInteraction*>::iterator it;
248 <            for (it = interactions_[key].begin();
249 <                 it != interactions_[key].end(); ++it) {
248 >            for (it = interactions_[atid1][atid2].begin();
249 >                 it != interactions_[atid1][atid2].end(); ++it) {
250                InteractionFamily ifam = (*it)->getFamily();
251                if (ifam == VANDERWAALS_FAMILY) {
252 <                interactions_[key].erase(*it);
253 <                // work on iHash here;
252 >                interactions_[atid1][atid2].erase(*it);
253 >                iHash_[atid1][atid2] ^= (*it)->getHash();
254                }
255              }
256 <            interactions_[key].insert(morse_);
257 <            iHash_[key] |= MORSE_PAIR;
256 >            interactions_[atid1][atid2].insert(morse_);
257 >            iHash_[atid1][atid2] |= MORSE_INTERACTION;
258              vdwExplicit = true;
259            }
260  
# Line 226 | Line 272 | namespace OpenMD {
272              // We found an explicit RepulsivePower interaction.  
273              // override all other vdw entries for this pair of atom types:
274              set<NonBondedInteraction*>::iterator it;
275 <            for (it = interactions_[key].begin();
276 <                 it != interactions_[key].end(); ++it) {
275 >            for (it = interactions_[atid1][atid2].begin();
276 >                 it != interactions_[atid1][atid2].end(); ++it) {
277                InteractionFamily ifam = (*it)->getFamily();
278                if (ifam == VANDERWAALS_FAMILY) {
279 <                interactions_[key].erase(*it);
280 <                // work on iHash here;
279 >                interactions_[atid1][atid2].erase(*it);
280 >                iHash_[atid1][atid2] ^= (*it)->getHash();
281                }
282              }
283 <            interactions_[key].insert(repulsivePower_);
284 <            iHash_[key] |= REPULSIVEPOWER_PAIR;
283 >            interactions_[atid1][atid2].insert(repulsivePower_);
284 >            iHash_[atid1][atid2] |= REPULSIVEPOWER_INTERACTION;
285              vdwExplicit = true;
286            }
287            
# Line 244 | Line 290 | namespace OpenMD {
290              // We found an explicit EAM interaction.  
291              // override all other metallic entries for this pair of atom types:
292              set<NonBondedInteraction*>::iterator it;
293 <            for (it = interactions_[key].begin();
294 <                 it != interactions_[key].end(); ++it) {
293 >            for (it = interactions_[atid1][atid2].begin();
294 >                 it != interactions_[atid1][atid2].end(); ++it) {
295                InteractionFamily ifam = (*it)->getFamily();
296                if (ifam == METALLIC_FAMILY) {
297 <                interactions_[key].erase(*it);
298 <                // work on iHash here;
297 >                interactions_[atid1][atid2].erase(*it);
298 >                iHash_[atid1][atid2] ^= (*it)->getHash();
299                }
300              }
301 <            interactions_[key].insert(eam_);
302 <            iHash_[key] |= EAM_PAIR;
301 >            interactions_[atid1][atid2].insert(eam_);
302 >            iHash_[atid1][atid2] |= EAM_INTERACTION;
303              metExplicit = true;
304            }
305            
# Line 271 | Line 317 | namespace OpenMD {
317              // We found an explicit Sutton-Chen interaction.  
318              // override all other metallic entries for this pair of atom types:
319              set<NonBondedInteraction*>::iterator it;
320 <            for (it = interactions_[key].begin();
321 <                 it != interactions_[key].end(); ++it) {
320 >            for (it = interactions_[atid1][atid2].begin();
321 >                 it != interactions_[atid1][atid2].end(); ++it) {
322                InteractionFamily ifam = (*it)->getFamily();
323                if (ifam == METALLIC_FAMILY) {
324 <                interactions_[key].erase(*it);
325 <                // work on iHash here;
324 >                interactions_[atid1][atid2].erase(*it);
325 >                iHash_[atid1][atid2] ^= (*it)->getHash();
326                }
327              }
328 <            interactions_[key].insert(sc_);
329 <            iHash_[key] |= SC_PAIR;
328 >            interactions_[atid1][atid2].insert(sc_);
329 >            iHash_[atid1][atid2] |= SC_INTERACTION;
330              metExplicit = true;
331            }
332            
# Line 298 | Line 344 | namespace OpenMD {
344              // We found an explicit MAW interaction.  
345              // override all other vdw entries for this pair of atom types:
346              set<NonBondedInteraction*>::iterator it;
347 <            for (it = interactions_[key].begin();
348 <                 it != interactions_[key].end(); ++it) {
347 >            for (it = interactions_[atid1][atid2].begin();
348 >                 it != interactions_[atid1][atid2].end(); ++it) {
349                InteractionFamily ifam = (*it)->getFamily();
350                if (ifam == VANDERWAALS_FAMILY) {
351 <                interactions_[key].erase(*it);
352 <                // work on iHash here;
351 >                interactions_[atid1][atid2].erase(*it);
352 >                iHash_[atid1][atid2] ^= (*it)->getHash();
353                }
354              }
355 <            interactions_[key].insert(maw_);
356 <            iHash_[key] |= MAW_PAIR;
355 >            interactions_[atid1][atid2].insert(maw_);
356 >            iHash_[atid1][atid2] |= MAW_INTERACTION;
357              vdwExplicit = true;
358            }        
359          }
# Line 323 | Line 369 | namespace OpenMD {
369  
370      for (it = simTypes.begin(); it != simTypes.end(); ++it) {
371        atype1 = (*it);
372 +      atid1 = atype1->getIdent();
373        for (jt = it; jt != simTypes.end(); ++jt) {
374          atype2 = (*jt);
375 <        key = make_pair(atype1, atype2);
375 >        atid2 = atype2->getIdent();
376          
377 <        if (interactions_[key].size() == 0) {
377 >        if (interactions_[atid1][atid2].size() == 0) {
378            sprintf( painCave.errMsg,
379                     "InteractionManager could not find a matching non-bonded\n"
380                     "\tinteraction for atom types %s - %s\n"
# Line 349 | Line 396 | namespace OpenMD {
396      eam_->setCutoffRadius(rcut);
397    }
398  
399 <  void InteractionManager::doPrePair(InteractionData idat){
399 >  void InteractionManager::doPrePair(InteractionData &idat){
400      
401      if (!initialized_) initialize();
402          
403      // excluded interaction, so just return
404      if (idat.excluded) return;
405  
406 <    int& iHash = iHash_[idat.atypes];
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 373 | Line 420 | namespace OpenMD {
420      return;    
421    }
422    
423 <  void InteractionManager::doPreForce(SelfData sdat){
423 >  void InteractionManager::doPreForce(SelfData &sdat){
424  
425      if (!initialized_) initialize();
426      
427 <    // pair<AtomType*, AtomType*> key = make_pair(sdat.atype, sdat.atype);
427 >    int& sHash = sHash_[sdat.atid];
428  
429 <    int& iHash = iHash_[ make_pair(sdat.atype, sdat.atype) ];
429 >    if ((sHash & EAM_INTERACTION) != 0)  eam_->calcFunctional(sdat);
430 >    if ((sHash & SC_INTERACTION) != 0)  sc_->calcFunctional(sdat);
431  
384 –    if ((iHash & EAM_PAIR) != 0) eam_->calcFunctional(sdat);
385 –    if ((iHash & SC_PAIR) != 0)  sc_->calcFunctional(sdat);
386 –
432      // set<NonBondedInteraction*>::iterator it;
433      
434 <    // for (it = interactions_[key].begin(); it != interactions_[key].end(); ++it){
434 >    // for (it = interactions_[atid1][atid2].begin(); it != interactions_[atid1][atid2].end(); ++it){
435      //   if ((*it)->getFamily() == METALLIC_FAMILY) {
436      //     dynamic_cast<MetallicInteraction*>(*it)->calcFunctional(sdat);
437      //   }
# Line 395 | Line 440 | namespace OpenMD {
440      return;    
441    }
442  
443 <  void InteractionManager::doPair(InteractionData idat){
443 >  void InteractionManager::doPair(InteractionData &idat){
444      
445      if (!initialized_) initialize();
446  
447 <    int& iHash = iHash_[idat.atypes];
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 433 | Line 478 | namespace OpenMD {
478      return;    
479    }
480  
481 <  void InteractionManager::doSelfCorrection(SelfData sdat){
481 >  void InteractionManager::doSelfCorrection(SelfData &sdat){
482  
483      if (!initialized_) initialize();
484      
485 <    int& iHash = iHash_[ make_pair(sdat.atype, sdat.atype) ];
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  
444 –
445 –    // pair<AtomType*, AtomType*> key = make_pair(sdat.atype, sdat.atype);
489      // set<NonBondedInteraction*>::iterator it;
490  
491 <    // for (it = interactions_[key].begin(); it != interactions_[key].end(); ++it){
491 >    // for (it = interactions_[atid1][atid2].begin(); it != interactions_[atid1][atid2].end(); ++it){
492      //   if ((*it)->getFamily() == ELECTROSTATIC_FAMILY) {
493      //     dynamic_cast<ElectrostaticInteraction*>(*it)->calcSelfCorrection(sdat);
494      //   }
# Line 454 | Line 497 | namespace OpenMD {
497      return;    
498    }
499  
500 +  void InteractionManager::doReciprocalSpaceSum(RealType &pot){
501 +    if (!initialized_) initialize();
502 +    electrostatic_->ReciprocalSpaceSum(pot);
503 +  }
504 +
505    RealType InteractionManager::getSuggestedCutoffRadius(int *atid) {
506      if (!initialized_) initialize();
507  
508      AtomType* atype = typeMap_[*atid];
509  
462 –    pair<AtomType*, AtomType*> key = make_pair(atype, atype);
510      set<NonBondedInteraction*>::iterator it;
511      RealType cutoff = 0.0;
512      
513 <    for (it = interactions_[key].begin(); it != interactions_[key].end(); ++it)
514 <      cutoff = max(cutoff, (*it)->getSuggestedCutoffRadius(key));  
513 >    for (it = interactions_[*atid][*atid].begin();
514 >         it != interactions_[*atid][*atid].end();
515 >         ++it)
516 >      cutoff = max(cutoff, (*it)->getSuggestedCutoffRadius(make_pair(atype,
517 >                                                                     atype)));
518      return cutoff;    
519    }
520  
521    RealType InteractionManager::getSuggestedCutoffRadius(AtomType* atype) {
522      if (!initialized_) initialize();
523      
524 <    pair<AtomType*, AtomType*> key = make_pair(atype, atype);
524 >    int atid = atype->getIdent();
525 >
526      set<NonBondedInteraction*>::iterator it;
527      RealType cutoff = 0.0;
528      
529 <    for (it = interactions_[key].begin(); it != interactions_[key].end(); ++it)
530 <      cutoff = max(cutoff, (*it)->getSuggestedCutoffRadius(key));  
529 >    for (it = interactions_[atid][atid].begin();
530 >         it != interactions_[atid][atid].end(); ++it)
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