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

Comparing branches/development/src/parallel/ForceMatrixDecomposition.cpp (file contents):
Revision 1586 by gezelter, Tue Jun 21 06:34:35 2011 UTC vs.
Revision 1736 by jmichalk, Tue Jun 5 17:51:31 2012 UTC

# Line 36 | Line 36
36   * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).            
37   * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
38   * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
39 < * [4]  Vardeman & Gezelter, in progress (2009).                        
39 > * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40 > * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
42   #include "parallel/ForceMatrixDecomposition.hpp"
43   #include "math/SquareMatrix3.hpp"
# Line 47 | Line 48 | namespace OpenMD {
48   using namespace std;
49   namespace OpenMD {
50  
51 +  ForceMatrixDecomposition::ForceMatrixDecomposition(SimInfo* info, InteractionManager* iMan) : ForceDecomposition(info, iMan) {
52 +
53 +    // In a parallel computation, row and colum scans must visit all
54 +    // surrounding cells (not just the 14 upper triangular blocks that
55 +    // are used when the processor can see all pairs)
56 + #ifdef IS_MPI
57 +    cellOffsets_.clear();
58 +    cellOffsets_.push_back( Vector3i(-1,-1,-1) );
59 +    cellOffsets_.push_back( Vector3i( 0,-1,-1) );
60 +    cellOffsets_.push_back( Vector3i( 1,-1,-1) );                          
61 +    cellOffsets_.push_back( Vector3i(-1, 0,-1) );
62 +    cellOffsets_.push_back( Vector3i( 0, 0,-1) );
63 +    cellOffsets_.push_back( Vector3i( 1, 0,-1) );
64 +    cellOffsets_.push_back( Vector3i(-1, 1,-1) );
65 +    cellOffsets_.push_back( Vector3i( 0, 1,-1) );      
66 +    cellOffsets_.push_back( Vector3i( 1, 1,-1) );
67 +    cellOffsets_.push_back( Vector3i(-1,-1, 0) );
68 +    cellOffsets_.push_back( Vector3i( 0,-1, 0) );
69 +    cellOffsets_.push_back( Vector3i( 1,-1, 0) );
70 +    cellOffsets_.push_back( Vector3i(-1, 0, 0) );      
71 +    cellOffsets_.push_back( Vector3i( 0, 0, 0) );
72 +    cellOffsets_.push_back( Vector3i( 1, 0, 0) );
73 +    cellOffsets_.push_back( Vector3i(-1, 1, 0) );
74 +    cellOffsets_.push_back( Vector3i( 0, 1, 0) );
75 +    cellOffsets_.push_back( Vector3i( 1, 1, 0) );
76 +    cellOffsets_.push_back( Vector3i(-1,-1, 1) );
77 +    cellOffsets_.push_back( Vector3i( 0,-1, 1) );
78 +    cellOffsets_.push_back( Vector3i( 1,-1, 1) );
79 +    cellOffsets_.push_back( Vector3i(-1, 0, 1) );
80 +    cellOffsets_.push_back( Vector3i( 0, 0, 1) );
81 +    cellOffsets_.push_back( Vector3i( 1, 0, 1) );
82 +    cellOffsets_.push_back( Vector3i(-1, 1, 1) );
83 +    cellOffsets_.push_back( Vector3i( 0, 1, 1) );
84 +    cellOffsets_.push_back( Vector3i( 1, 1, 1) );
85 + #endif    
86 +  }
87 +
88 +
89    /**
90     * distributeInitialData is essentially a copy of the older fortran
91     * SimulationSetup
92     */
54 –  
93    void ForceMatrixDecomposition::distributeInitialData() {
94      snap_ = sman_->getCurrentSnapshot();
95      storageLayout_ = sman_->getStorageLayout();
96      ff_ = info_->getForceField();
97      nLocal_ = snap_->getNumberOfAtoms();
98 <
98 >  
99      nGroups_ = info_->getNLocalCutoffGroups();
100      // gather the information for atomtype IDs (atids):
101      idents = info_->getIdentArray();
# Line 67 | Line 105 | namespace OpenMD {
105  
106      massFactors = info_->getMassFactors();
107  
108 <    PairList excludes = info_->getExcludedInteractions();
109 <    PairList oneTwo = info_->getOneTwoInteractions();
110 <    PairList oneThree = info_->getOneThreeInteractions();
111 <    PairList oneFour = info_->getOneFourInteractions();
112 <
108 >    PairList* excludes = info_->getExcludedInteractions();
109 >    PairList* oneTwo = info_->getOneTwoInteractions();
110 >    PairList* oneThree = info_->getOneThreeInteractions();
111 >    PairList* oneFour = info_->getOneFourInteractions();
112 >    
113 >    if (needVelocities_)
114 >      snap_->cgData.setStorageLayout(DataStorage::dslPosition |
115 >                                     DataStorage::dslVelocity);
116 >    else
117 >      snap_->cgData.setStorageLayout(DataStorage::dslPosition);
118 >    
119   #ifdef IS_MPI
120  
121 <    AtomCommIntRow = new Communicator<Row,int>(nLocal_);
122 <    AtomCommRealRow = new Communicator<Row,RealType>(nLocal_);
79 <    AtomCommVectorRow = new Communicator<Row,Vector3d>(nLocal_);
80 <    AtomCommMatrixRow = new Communicator<Row,Mat3x3d>(nLocal_);
81 <    AtomCommPotRow = new Communicator<Row,potVec>(nLocal_);
121 >    MPI::Intracomm row = rowComm.getComm();
122 >    MPI::Intracomm col = colComm.getComm();
123  
124 <    AtomCommIntColumn = new Communicator<Column,int>(nLocal_);
125 <    AtomCommRealColumn = new Communicator<Column,RealType>(nLocal_);
126 <    AtomCommVectorColumn = new Communicator<Column,Vector3d>(nLocal_);
127 <    AtomCommMatrixColumn = new Communicator<Column,Mat3x3d>(nLocal_);
128 <    AtomCommPotColumn = new Communicator<Column,potVec>(nLocal_);
124 >    AtomPlanIntRow = new Plan<int>(row, nLocal_);
125 >    AtomPlanRealRow = new Plan<RealType>(row, nLocal_);
126 >    AtomPlanVectorRow = new Plan<Vector3d>(row, nLocal_);
127 >    AtomPlanMatrixRow = new Plan<Mat3x3d>(row, nLocal_);
128 >    AtomPlanPotRow = new Plan<potVec>(row, nLocal_);
129  
130 <    cgCommIntRow = new Communicator<Row,int>(nGroups_);
131 <    cgCommVectorRow = new Communicator<Row,Vector3d>(nGroups_);
132 <    cgCommIntColumn = new Communicator<Column,int>(nGroups_);
133 <    cgCommVectorColumn = new Communicator<Column,Vector3d>(nGroups_);
130 >    AtomPlanIntColumn = new Plan<int>(col, nLocal_);
131 >    AtomPlanRealColumn = new Plan<RealType>(col, nLocal_);
132 >    AtomPlanVectorColumn = new Plan<Vector3d>(col, nLocal_);
133 >    AtomPlanMatrixColumn = new Plan<Mat3x3d>(col, nLocal_);
134 >    AtomPlanPotColumn = new Plan<potVec>(col, nLocal_);
135  
136 <    nAtomsInRow_ = AtomCommIntRow->getSize();
137 <    nAtomsInCol_ = AtomCommIntColumn->getSize();
138 <    nGroupsInRow_ = cgCommIntRow->getSize();
139 <    nGroupsInCol_ = cgCommIntColumn->getSize();
136 >    cgPlanIntRow = new Plan<int>(row, nGroups_);
137 >    cgPlanVectorRow = new Plan<Vector3d>(row, nGroups_);
138 >    cgPlanIntColumn = new Plan<int>(col, nGroups_);
139 >    cgPlanVectorColumn = new Plan<Vector3d>(col, nGroups_);
140  
141 +    nAtomsInRow_ = AtomPlanIntRow->getSize();
142 +    nAtomsInCol_ = AtomPlanIntColumn->getSize();
143 +    nGroupsInRow_ = cgPlanIntRow->getSize();
144 +    nGroupsInCol_ = cgPlanIntColumn->getSize();
145 +
146      // Modify the data storage objects with the correct layouts and sizes:
147      atomRowData.resize(nAtomsInRow_);
148      atomRowData.setStorageLayout(storageLayout_);
# Line 104 | Line 151 | namespace OpenMD {
151      cgRowData.resize(nGroupsInRow_);
152      cgRowData.setStorageLayout(DataStorage::dslPosition);
153      cgColData.resize(nGroupsInCol_);
154 <    cgColData.setStorageLayout(DataStorage::dslPosition);
155 <        
154 >    if (needVelocities_)
155 >      // we only need column velocities if we need them.
156 >      cgColData.setStorageLayout(DataStorage::dslPosition |
157 >                                 DataStorage::dslVelocity);
158 >    else    
159 >      cgColData.setStorageLayout(DataStorage::dslPosition);
160 >      
161      identsRow.resize(nAtomsInRow_);
162      identsCol.resize(nAtomsInCol_);
163      
164 <    AtomCommIntRow->gather(idents, identsRow);
165 <    AtomCommIntColumn->gather(idents, identsCol);
164 >    AtomPlanIntRow->gather(idents, identsRow);
165 >    AtomPlanIntColumn->gather(idents, identsCol);
166      
167 <    AtomCommIntRow->gather(AtomLocalToGlobal, AtomRowToGlobal);
168 <    AtomCommIntColumn->gather(AtomLocalToGlobal, AtomColToGlobal);
169 <    
118 <    cgCommIntRow->gather(cgLocalToGlobal, cgRowToGlobal);
119 <    cgCommIntColumn->gather(cgLocalToGlobal, cgColToGlobal);
167 >    // allocate memory for the parallel objects
168 >    atypesRow.resize(nAtomsInRow_);
169 >    atypesCol.resize(nAtomsInCol_);
170  
171 <    AtomCommRealRow->gather(massFactors, massFactorsRow);
172 <    AtomCommRealColumn->gather(massFactors, massFactorsCol);
171 >    for (int i = 0; i < nAtomsInRow_; i++)
172 >      atypesRow[i] = ff_->getAtomType(identsRow[i]);
173 >    for (int i = 0; i < nAtomsInCol_; i++)
174 >      atypesCol[i] = ff_->getAtomType(identsCol[i]);        
175 >
176 >    pot_row.resize(nAtomsInRow_);
177 >    pot_col.resize(nAtomsInCol_);
178 >
179 >    AtomRowToGlobal.resize(nAtomsInRow_);
180 >    AtomColToGlobal.resize(nAtomsInCol_);
181 >    AtomPlanIntRow->gather(AtomLocalToGlobal, AtomRowToGlobal);
182 >    AtomPlanIntColumn->gather(AtomLocalToGlobal, AtomColToGlobal);
183  
184 +    cgRowToGlobal.resize(nGroupsInRow_);
185 +    cgColToGlobal.resize(nGroupsInCol_);
186 +    cgPlanIntRow->gather(cgLocalToGlobal, cgRowToGlobal);
187 +    cgPlanIntColumn->gather(cgLocalToGlobal, cgColToGlobal);
188 +
189 +    massFactorsRow.resize(nAtomsInRow_);
190 +    massFactorsCol.resize(nAtomsInCol_);
191 +    AtomPlanRealRow->gather(massFactors, massFactorsRow);
192 +    AtomPlanRealColumn->gather(massFactors, massFactorsCol);
193 +
194      groupListRow_.clear();
195      groupListRow_.resize(nGroupsInRow_);
196      for (int i = 0; i < nGroupsInRow_; i++) {
# Line 143 | Line 213 | namespace OpenMD {
213        }      
214      }
215  
216 <    skipsForAtom.clear();
217 <    skipsForAtom.resize(nAtomsInRow_);
216 >    excludesForAtom.clear();
217 >    excludesForAtom.resize(nAtomsInRow_);
218      toposForAtom.clear();
219      toposForAtom.resize(nAtomsInRow_);
220      topoDist.clear();
# Line 155 | Line 225 | namespace OpenMD {
225        for (int j = 0; j < nAtomsInCol_; j++) {
226          int jglob = AtomColToGlobal[j];
227  
228 <        if (excludes.hasPair(iglob, jglob))
229 <          skipsForAtom[i].push_back(j);      
228 >        if (excludes->hasPair(iglob, jglob))
229 >          excludesForAtom[i].push_back(j);      
230          
231 <        if (oneTwo.hasPair(iglob, jglob)) {
231 >        if (oneTwo->hasPair(iglob, jglob)) {
232            toposForAtom[i].push_back(j);
233            topoDist[i].push_back(1);
234          } else {
235 <          if (oneThree.hasPair(iglob, jglob)) {
235 >          if (oneThree->hasPair(iglob, jglob)) {
236              toposForAtom[i].push_back(j);
237              topoDist[i].push_back(2);
238            } else {
239 <            if (oneFour.hasPair(iglob, jglob)) {
239 >            if (oneFour->hasPair(iglob, jglob)) {
240                toposForAtom[i].push_back(j);
241                topoDist[i].push_back(3);
242              }
# Line 175 | Line 245 | namespace OpenMD {
245        }      
246      }
247  
248 < #endif
249 <
250 <    groupList_.clear();
181 <    groupList_.resize(nGroups_);
182 <    for (int i = 0; i < nGroups_; i++) {
183 <      int gid = cgLocalToGlobal[i];
184 <      for (int j = 0; j < nLocal_; j++) {
185 <        int aid = AtomLocalToGlobal[j];
186 <        if (globalGroupMembership[aid] == gid) {
187 <          groupList_[i].push_back(j);
188 <        }
189 <      }      
190 <    }
191 <
192 <    skipsForAtom.clear();
193 <    skipsForAtom.resize(nLocal_);
248 > #else
249 >    excludesForAtom.clear();
250 >    excludesForAtom.resize(nLocal_);
251      toposForAtom.clear();
252      toposForAtom.resize(nLocal_);
253      topoDist.clear();
# Line 202 | Line 259 | namespace OpenMD {
259        for (int j = 0; j < nLocal_; j++) {
260          int jglob = AtomLocalToGlobal[j];
261  
262 <        if (excludes.hasPair(iglob, jglob))
263 <          skipsForAtom[i].push_back(j);              
262 >        if (excludes->hasPair(iglob, jglob))
263 >          excludesForAtom[i].push_back(j);              
264          
265 <        if (oneTwo.hasPair(iglob, jglob)) {
265 >        if (oneTwo->hasPair(iglob, jglob)) {
266            toposForAtom[i].push_back(j);
267            topoDist[i].push_back(1);
268          } else {
269 <          if (oneThree.hasPair(iglob, jglob)) {
269 >          if (oneThree->hasPair(iglob, jglob)) {
270              toposForAtom[i].push_back(j);
271              topoDist[i].push_back(2);
272            } else {
273 <            if (oneFour.hasPair(iglob, jglob)) {
273 >            if (oneFour->hasPair(iglob, jglob)) {
274                toposForAtom[i].push_back(j);
275                topoDist[i].push_back(3);
276              }
# Line 221 | Line 278 | namespace OpenMD {
278          }
279        }      
280      }
281 <    
281 > #endif
282 >
283 >    // allocate memory for the parallel objects
284 >    atypesLocal.resize(nLocal_);
285 >
286 >    for (int i = 0; i < nLocal_; i++)
287 >      atypesLocal[i] = ff_->getAtomType(idents[i]);
288 >
289 >    groupList_.clear();
290 >    groupList_.resize(nGroups_);
291 >    for (int i = 0; i < nGroups_; i++) {
292 >      int gid = cgLocalToGlobal[i];
293 >      for (int j = 0; j < nLocal_; j++) {
294 >        int aid = AtomLocalToGlobal[j];
295 >        if (globalGroupMembership[aid] == gid) {
296 >          groupList_[i].push_back(j);
297 >        }
298 >      }      
299 >    }
300 >
301 >
302      createGtypeCutoffMap();
303 +
304    }
305    
306    void ForceMatrixDecomposition::createGtypeCutoffMap() {
307      
308      RealType tol = 1e-6;
309 +    largestRcut_ = 0.0;
310      RealType rc;
311      int atid;
312      set<AtomType*> atypes = info_->getSimulatedAtomTypes();
313 <    vector<RealType> atypeCutoff;
314 <    atypeCutoff.resize( atypes.size() );
313 >    
314 >    map<int, RealType> atypeCutoff;
315        
316      for (set<AtomType*>::iterator at = atypes.begin();
317           at != atypes.end(); ++at){
318        atid = (*at)->getIdent();
319 <
241 <      if (userChoseCutoff_)
319 >      if (userChoseCutoff_)
320          atypeCutoff[atid] = userCutoff_;
321        else
322          atypeCutoff[atid] = interactionMan_->getSuggestedCutoffRadius(*at);
323      }
324 <
324 >    
325      vector<RealType> gTypeCutoffs;
248 –
326      // first we do a single loop over the cutoff groups to find the
327      // largest cutoff for any atypes present in this group.
328   #ifdef IS_MPI
# Line 303 | Line 380 | namespace OpenMD {
380  
381      vector<RealType> groupCutoff(nGroups_, 0.0);
382      groupToGtype.resize(nGroups_);
306 –
383      for (int cg1 = 0; cg1 < nGroups_; cg1++) {
308 –
384        groupCutoff[cg1] = 0.0;
385        vector<int> atomList = getAtomsInGroupRow(cg1);
311 –
386        for (vector<int>::iterator ia = atomList.begin();
387             ia != atomList.end(); ++ia) {            
388          int atom1 = (*ia);
389          atid = idents[atom1];
390 <        if (atypeCutoff[atid] > groupCutoff[cg1]) {
390 >        if (atypeCutoff[atid] > groupCutoff[cg1])
391            groupCutoff[cg1] = atypeCutoff[atid];
318 –        }
392        }
393 <
393 >      
394        bool gTypeFound = false;
395        for (int gt = 0; gt < gTypeCutoffs.size(); gt++) {
396          if (abs(groupCutoff[cg1] - gTypeCutoffs[gt]) < tol) {
# Line 325 | Line 398 | namespace OpenMD {
398            gTypeFound = true;
399          }
400        }
401 <      if (!gTypeFound) {
401 >      if (!gTypeFound) {      
402          gTypeCutoffs.push_back( groupCutoff[cg1] );
403          groupToGtype[cg1] = gTypeCutoffs.size() - 1;
404        }      
# Line 334 | Line 407 | namespace OpenMD {
407  
408      // Now we find the maximum group cutoff value present in the simulation
409  
410 <    RealType groupMax = *max_element(gTypeCutoffs.begin(), gTypeCutoffs.end());
410 >    RealType groupMax = *max_element(gTypeCutoffs.begin(),
411 >                                     gTypeCutoffs.end());
412  
413   #ifdef IS_MPI
414 <    MPI::COMM_WORLD.Allreduce(&groupMax, &groupMax, 1, MPI::REALTYPE, MPI::MAX);
414 >    MPI::COMM_WORLD.Allreduce(&groupMax, &groupMax, 1, MPI::REALTYPE,
415 >                              MPI::MAX);
416   #endif
417      
418      RealType tradRcut = groupMax;
# Line 367 | Line 442 | namespace OpenMD {
442  
443          pair<int,int> key = make_pair(i,j);
444          gTypeCutoffMap[key].first = thisRcut;
370 –
445          if (thisRcut > largestRcut_) largestRcut_ = thisRcut;
372 –
446          gTypeCutoffMap[key].second = thisRcut*thisRcut;
374 –        
447          gTypeCutoffMap[key].third = pow(thisRcut + skinThickness_, 2);
376 –
448          // sanity check
449          
450          if (userChoseCutoff_) {
# Line 433 | Line 504 | namespace OpenMD {
504           Vector<RealType, N_INTERACTION_FAMILIES> (0.0));  
505  
506      if (storageLayout_ & DataStorage::dslParticlePot) {    
507 <      fill(atomRowData.particlePot.begin(), atomRowData.particlePot.end(), 0.0);
508 <      fill(atomColData.particlePot.begin(), atomColData.particlePot.end(), 0.0);
507 >      fill(atomRowData.particlePot.begin(), atomRowData.particlePot.end(),
508 >           0.0);
509 >      fill(atomColData.particlePot.begin(), atomColData.particlePot.end(),
510 >           0.0);
511      }
512  
513      if (storageLayout_ & DataStorage::dslDensity) {      
# Line 443 | Line 516 | namespace OpenMD {
516      }
517  
518      if (storageLayout_ & DataStorage::dslFunctional) {  
519 <      fill(atomRowData.functional.begin(), atomRowData.functional.end(), 0.0);
520 <      fill(atomColData.functional.begin(), atomColData.functional.end(), 0.0);
519 >      fill(atomRowData.functional.begin(), atomRowData.functional.end(),
520 >           0.0);
521 >      fill(atomColData.functional.begin(), atomColData.functional.end(),
522 >           0.0);
523      }
524  
525      if (storageLayout_ & DataStorage::dslFunctionalDerivative) {      
# Line 455 | Line 530 | namespace OpenMD {
530      }
531  
532      if (storageLayout_ & DataStorage::dslSkippedCharge) {      
533 <      fill(atomRowData.skippedCharge.begin(), atomRowData.skippedCharge.end(), 0.0);
534 <      fill(atomColData.skippedCharge.begin(), atomColData.skippedCharge.end(), 0.0);
533 >      fill(atomRowData.skippedCharge.begin(),
534 >           atomRowData.skippedCharge.end(), 0.0);
535 >      fill(atomColData.skippedCharge.begin(),
536 >           atomColData.skippedCharge.end(), 0.0);
537      }
538  
539 < #else
540 <    
539 >    if (storageLayout_ & DataStorage::dslFlucQForce) {      
540 >      fill(atomRowData.flucQFrc.begin(),
541 >           atomRowData.flucQFrc.end(), 0.0);
542 >      fill(atomColData.flucQFrc.begin(),
543 >           atomColData.flucQFrc.end(), 0.0);
544 >    }
545 >
546 >    if (storageLayout_ & DataStorage::dslElectricField) {    
547 >      fill(atomRowData.electricField.begin(),
548 >           atomRowData.electricField.end(), V3Zero);
549 >      fill(atomColData.electricField.begin(),
550 >           atomColData.electricField.end(), V3Zero);
551 >    }
552 >
553 >    if (storageLayout_ & DataStorage::dslFlucQForce) {    
554 >      fill(atomRowData.flucQFrc.begin(), atomRowData.flucQFrc.end(),
555 >           0.0);
556 >      fill(atomColData.flucQFrc.begin(), atomColData.flucQFrc.end(),
557 >           0.0);
558 >    }
559 >
560 > #endif
561 >    // even in parallel, we need to zero out the local arrays:
562 >
563      if (storageLayout_ & DataStorage::dslParticlePot) {      
564        fill(snap_->atomData.particlePot.begin(),
565             snap_->atomData.particlePot.end(), 0.0);
# Line 470 | Line 569 | namespace OpenMD {
569        fill(snap_->atomData.density.begin(),
570             snap_->atomData.density.end(), 0.0);
571      }
572 +
573      if (storageLayout_ & DataStorage::dslFunctional) {
574        fill(snap_->atomData.functional.begin(),
575             snap_->atomData.functional.end(), 0.0);
576      }
577 +
578      if (storageLayout_ & DataStorage::dslFunctionalDerivative) {      
579        fill(snap_->atomData.functionalDerivative.begin(),
580             snap_->atomData.functionalDerivative.end(), 0.0);
581      }
582 +
583      if (storageLayout_ & DataStorage::dslSkippedCharge) {      
584        fill(snap_->atomData.skippedCharge.begin(),
585             snap_->atomData.skippedCharge.end(), 0.0);
586      }
587 < #endif
588 <    
587 >
588 >    if (storageLayout_ & DataStorage::dslElectricField) {      
589 >      fill(snap_->atomData.electricField.begin(),
590 >           snap_->atomData.electricField.end(), V3Zero);
591 >    }
592    }
593  
594  
# Line 493 | Line 598 | namespace OpenMD {
598   #ifdef IS_MPI
599      
600      // gather up the atomic positions
601 <    AtomCommVectorRow->gather(snap_->atomData.position,
601 >    AtomPlanVectorRow->gather(snap_->atomData.position,
602                                atomRowData.position);
603 <    AtomCommVectorColumn->gather(snap_->atomData.position,
603 >    AtomPlanVectorColumn->gather(snap_->atomData.position,
604                                   atomColData.position);
605      
606      // gather up the cutoff group positions
607 <    cgCommVectorRow->gather(snap_->cgData.position,
607 >
608 >    cgPlanVectorRow->gather(snap_->cgData.position,
609                              cgRowData.position);
610 <    cgCommVectorColumn->gather(snap_->cgData.position,
610 >
611 >    cgPlanVectorColumn->gather(snap_->cgData.position,
612                                 cgColData.position);
613 +
614 +
615 +
616 +    if (needVelocities_) {
617 +      // gather up the atomic velocities
618 +      AtomPlanVectorColumn->gather(snap_->atomData.velocity,
619 +                                   atomColData.velocity);
620 +      
621 +      cgPlanVectorColumn->gather(snap_->cgData.velocity,
622 +                                 cgColData.velocity);
623 +    }
624 +
625      
626      // if needed, gather the atomic rotation matrices
627      if (storageLayout_ & DataStorage::dslAmat) {
628 <      AtomCommMatrixRow->gather(snap_->atomData.aMat,
628 >      AtomPlanMatrixRow->gather(snap_->atomData.aMat,
629                                  atomRowData.aMat);
630 <      AtomCommMatrixColumn->gather(snap_->atomData.aMat,
630 >      AtomPlanMatrixColumn->gather(snap_->atomData.aMat,
631                                     atomColData.aMat);
632      }
633      
634      // if needed, gather the atomic eletrostatic frames
635      if (storageLayout_ & DataStorage::dslElectroFrame) {
636 <      AtomCommMatrixRow->gather(snap_->atomData.electroFrame,
636 >      AtomPlanMatrixRow->gather(snap_->atomData.electroFrame,
637                                  atomRowData.electroFrame);
638 <      AtomCommMatrixColumn->gather(snap_->atomData.electroFrame,
638 >      AtomPlanMatrixColumn->gather(snap_->atomData.electroFrame,
639                                     atomColData.electroFrame);
640      }
641 +
642 +    // if needed, gather the atomic fluctuating charge values
643 +    if (storageLayout_ & DataStorage::dslFlucQPosition) {
644 +      AtomPlanRealRow->gather(snap_->atomData.flucQPos,
645 +                              atomRowData.flucQPos);
646 +      AtomPlanRealColumn->gather(snap_->atomData.flucQPos,
647 +                                 atomColData.flucQPos);
648 +    }
649 +
650   #endif      
651    }
652    
# Line 532 | Line 660 | namespace OpenMD {
660      
661      if (storageLayout_ & DataStorage::dslDensity) {
662        
663 <      AtomCommRealRow->scatter(atomRowData.density,
663 >      AtomPlanRealRow->scatter(atomRowData.density,
664                                 snap_->atomData.density);
665        
666        int n = snap_->atomData.density.size();
667        vector<RealType> rho_tmp(n, 0.0);
668 <      AtomCommRealColumn->scatter(atomColData.density, rho_tmp);
668 >      AtomPlanRealColumn->scatter(atomColData.density, rho_tmp);
669        for (int i = 0; i < n; i++)
670          snap_->atomData.density[i] += rho_tmp[i];
671      }
672 +
673 +    if (storageLayout_ & DataStorage::dslElectricField) {
674 +      
675 +      AtomPlanVectorRow->scatter(atomRowData.electricField,
676 +                                 snap_->atomData.electricField);
677 +      
678 +      int n = snap_->atomData.electricField.size();
679 +      vector<Vector3d> field_tmp(n, V3Zero);
680 +      AtomPlanVectorColumn->scatter(atomColData.electricField, field_tmp);
681 +      for (int i = 0; i < n; i++)
682 +        snap_->atomData.electricField[i] += field_tmp[i];
683 +    }
684   #endif
685    }
686  
# Line 553 | Line 693 | namespace OpenMD {
693      storageLayout_ = sman_->getStorageLayout();
694   #ifdef IS_MPI
695      if (storageLayout_ & DataStorage::dslFunctional) {
696 <      AtomCommRealRow->gather(snap_->atomData.functional,
696 >      AtomPlanRealRow->gather(snap_->atomData.functional,
697                                atomRowData.functional);
698 <      AtomCommRealColumn->gather(snap_->atomData.functional,
698 >      AtomPlanRealColumn->gather(snap_->atomData.functional,
699                                   atomColData.functional);
700      }
701      
702      if (storageLayout_ & DataStorage::dslFunctionalDerivative) {
703 <      AtomCommRealRow->gather(snap_->atomData.functionalDerivative,
703 >      AtomPlanRealRow->gather(snap_->atomData.functionalDerivative,
704                                atomRowData.functionalDerivative);
705 <      AtomCommRealColumn->gather(snap_->atomData.functionalDerivative,
705 >      AtomPlanRealColumn->gather(snap_->atomData.functionalDerivative,
706                                   atomColData.functionalDerivative);
707      }
708   #endif
# Line 576 | Line 716 | namespace OpenMD {
716      int n = snap_->atomData.force.size();
717      vector<Vector3d> frc_tmp(n, V3Zero);
718      
719 <    AtomCommVectorRow->scatter(atomRowData.force, frc_tmp);
719 >    AtomPlanVectorRow->scatter(atomRowData.force, frc_tmp);
720      for (int i = 0; i < n; i++) {
721        snap_->atomData.force[i] += frc_tmp[i];
722        frc_tmp[i] = 0.0;
723      }
724      
725 <    AtomCommVectorColumn->scatter(atomColData.force, frc_tmp);
726 <    for (int i = 0; i < n; i++)
725 >    AtomPlanVectorColumn->scatter(atomColData.force, frc_tmp);
726 >    for (int i = 0; i < n; i++) {
727        snap_->atomData.force[i] += frc_tmp[i];
728 <    
729 <    
728 >    }
729 >        
730      if (storageLayout_ & DataStorage::dslTorque) {
731  
732 <      int nt = snap_->atomData.force.size();
732 >      int nt = snap_->atomData.torque.size();
733        vector<Vector3d> trq_tmp(nt, V3Zero);
734  
735 <      AtomCommVectorRow->scatter(atomRowData.torque, trq_tmp);
736 <      for (int i = 0; i < n; i++) {
735 >      AtomPlanVectorRow->scatter(atomRowData.torque, trq_tmp);
736 >      for (int i = 0; i < nt; i++) {
737          snap_->atomData.torque[i] += trq_tmp[i];
738          trq_tmp[i] = 0.0;
739        }
740        
741 <      AtomCommVectorColumn->scatter(atomColData.torque, trq_tmp);
742 <      for (int i = 0; i < n; i++)
741 >      AtomPlanVectorColumn->scatter(atomColData.torque, trq_tmp);
742 >      for (int i = 0; i < nt; i++)
743          snap_->atomData.torque[i] += trq_tmp[i];
744      }
745 +
746 +    if (storageLayout_ & DataStorage::dslSkippedCharge) {
747 +
748 +      int ns = snap_->atomData.skippedCharge.size();
749 +      vector<RealType> skch_tmp(ns, 0.0);
750 +
751 +      AtomPlanRealRow->scatter(atomRowData.skippedCharge, skch_tmp);
752 +      for (int i = 0; i < ns; i++) {
753 +        snap_->atomData.skippedCharge[i] += skch_tmp[i];
754 +        skch_tmp[i] = 0.0;
755 +      }
756 +      
757 +      AtomPlanRealColumn->scatter(atomColData.skippedCharge, skch_tmp);
758 +      for (int i = 0; i < ns; i++)
759 +        snap_->atomData.skippedCharge[i] += skch_tmp[i];
760 +            
761 +    }
762      
763 +    if (storageLayout_ & DataStorage::dslFlucQForce) {
764 +
765 +      int nq = snap_->atomData.flucQFrc.size();
766 +      vector<RealType> fqfrc_tmp(nq, 0.0);
767 +
768 +      AtomPlanRealRow->scatter(atomRowData.flucQFrc, fqfrc_tmp);
769 +      for (int i = 0; i < nq; i++) {
770 +        snap_->atomData.flucQFrc[i] += fqfrc_tmp[i];
771 +        fqfrc_tmp[i] = 0.0;
772 +      }
773 +      
774 +      AtomPlanRealColumn->scatter(atomColData.flucQFrc, fqfrc_tmp);
775 +      for (int i = 0; i < nq; i++)
776 +        snap_->atomData.flucQFrc[i] += fqfrc_tmp[i];
777 +            
778 +    }
779 +
780      nLocal_ = snap_->getNumberOfAtoms();
781  
782      vector<potVec> pot_temp(nLocal_,
# Line 610 | Line 784 | namespace OpenMD {
784  
785      // scatter/gather pot_row into the members of my column
786            
787 <    AtomCommPotRow->scatter(pot_row, pot_temp);
787 >    AtomPlanPotRow->scatter(pot_row, pot_temp);
788  
789      for (int ii = 0;  ii < pot_temp.size(); ii++ )
790        pairwisePot += pot_temp[ii];
791 <    
791 >        
792 >    if (storageLayout_ & DataStorage::dslParticlePot) {
793 >      // This is the pairwise contribution to the particle pot.  The
794 >      // embedding contribution is added in each of the low level
795 >      // non-bonded routines.  In single processor, this is done in
796 >      // unpackInteractionData, not in collectData.
797 >      for (int ii = 0; ii < N_INTERACTION_FAMILIES; ii++) {
798 >        for (int i = 0; i < nLocal_; i++) {
799 >          // factor of two is because the total potential terms are divided
800 >          // by 2 in parallel due to row/ column scatter      
801 >          snap_->atomData.particlePot[i] += 2.0 * pot_temp[i](ii);
802 >        }
803 >      }
804 >    }
805 >
806      fill(pot_temp.begin(), pot_temp.end(),
807           Vector<RealType, N_INTERACTION_FAMILIES> (0.0));
808        
809 <    AtomCommPotColumn->scatter(pot_col, pot_temp);    
809 >    AtomPlanPotColumn->scatter(pot_col, pot_temp);    
810      
811      for (int ii = 0;  ii < pot_temp.size(); ii++ )
812        pairwisePot += pot_temp[ii];    
813 +
814 +    if (storageLayout_ & DataStorage::dslParticlePot) {
815 +      // This is the pairwise contribution to the particle pot.  The
816 +      // embedding contribution is added in each of the low level
817 +      // non-bonded routines.  In single processor, this is done in
818 +      // unpackInteractionData, not in collectData.
819 +      for (int ii = 0; ii < N_INTERACTION_FAMILIES; ii++) {
820 +        for (int i = 0; i < nLocal_; i++) {
821 +          // factor of two is because the total potential terms are divided
822 +          // by 2 in parallel due to row/ column scatter      
823 +          snap_->atomData.particlePot[i] += 2.0 * pot_temp[i](ii);
824 +        }
825 +      }
826 +    }
827 +    
828 +    if (storageLayout_ & DataStorage::dslParticlePot) {
829 +      int npp = snap_->atomData.particlePot.size();
830 +      vector<RealType> ppot_temp(npp, 0.0);
831 +
832 +      // This is the direct or embedding contribution to the particle
833 +      // pot.
834 +      
835 +      AtomPlanRealRow->scatter(atomRowData.particlePot, ppot_temp);
836 +      for (int i = 0; i < npp; i++) {
837 +        snap_->atomData.particlePot[i] += ppot_temp[i];
838 +      }
839 +
840 +      fill(ppot_temp.begin(), ppot_temp.end(), 0.0);
841 +      
842 +      AtomPlanRealColumn->scatter(atomColData.particlePot, ppot_temp);
843 +      for (int i = 0; i < npp; i++) {
844 +        snap_->atomData.particlePot[i] += ppot_temp[i];
845 +      }
846 +    }
847 +
848 +    for (int ii = 0; ii < N_INTERACTION_FAMILIES; ii++) {
849 +      RealType ploc1 = pairwisePot[ii];
850 +      RealType ploc2 = 0.0;
851 +      MPI::COMM_WORLD.Allreduce(&ploc1, &ploc2, 1, MPI::REALTYPE, MPI::SUM);
852 +      pairwisePot[ii] = ploc2;
853 +    }
854 +
855 +    for (int ii = 0; ii < N_INTERACTION_FAMILIES; ii++) {
856 +      RealType ploc1 = embeddingPot[ii];
857 +      RealType ploc2 = 0.0;
858 +      MPI::COMM_WORLD.Allreduce(&ploc1, &ploc2, 1, MPI::REALTYPE, MPI::SUM);
859 +      embeddingPot[ii] = ploc2;
860 +    }
861 +    
862 +    // Here be dragons.
863 +    MPI::Intracomm col = colComm.getComm();
864 +
865 +    col.Allreduce(MPI::IN_PLACE,
866 +                  &snap_->frameData.conductiveHeatFlux[0], 3,
867 +                  MPI::REALTYPE, MPI::SUM);
868 +
869 +
870   #endif
871  
872    }
# Line 666 | Line 911 | namespace OpenMD {
911      return d;    
912    }
913  
914 +  Vector3d ForceMatrixDecomposition::getGroupVelocityColumn(int cg2){
915 + #ifdef IS_MPI
916 +    return cgColData.velocity[cg2];
917 + #else
918 +    return snap_->cgData.velocity[cg2];
919 + #endif
920 +  }
921  
922 +  Vector3d ForceMatrixDecomposition::getAtomVelocityColumn(int atom2){
923 + #ifdef IS_MPI
924 +    return atomColData.velocity[atom2];
925 + #else
926 +    return snap_->atomData.velocity[atom2];
927 + #endif
928 +  }
929 +
930 +
931    Vector3d ForceMatrixDecomposition::getAtomToGroupVectorRow(int atom1, int cg1){
932  
933      Vector3d d;
# Line 724 | Line 985 | namespace OpenMD {
985      return d;    
986    }
987  
988 <  vector<int> ForceMatrixDecomposition::getSkipsForAtom(int atom1) {
989 <    return skipsForAtom[atom1];
988 >  vector<int> ForceMatrixDecomposition::getExcludesForAtom(int atom1) {
989 >    return excludesForAtom[atom1];
990    }
991  
992    /**
993 <   * There are a number of reasons to skip a pair or a
733 <   * particle. Mostly we do this to exclude atoms who are involved in
734 <   * short range interactions (bonds, bends, torsions), but we also
735 <   * need to exclude some overcounted interactions that result from
993 >   * We need to exclude some overcounted interactions that result from
994     * the parallel decomposition.
995     */
996    bool ForceMatrixDecomposition::skipAtomPair(int atom1, int atom2) {
997      int unique_id_1, unique_id_2;
998 <
998 >        
999   #ifdef IS_MPI
1000      // in MPI, we have to look up the unique IDs for each atom
1001      unique_id_1 = AtomRowToGlobal[atom1];
1002      unique_id_2 = AtomColToGlobal[atom2];
1003 + #else
1004 +    unique_id_1 = AtomLocalToGlobal[atom1];
1005 +    unique_id_2 = AtomLocalToGlobal[atom2];
1006 + #endif  
1007  
746 –    // this situation should only arise in MPI simulations
1008      if (unique_id_1 == unique_id_2) return true;
1009 <    
1009 >
1010 > #ifdef IS_MPI
1011      // this prevents us from doing the pair on multiple processors
1012      if (unique_id_1 < unique_id_2) {
1013        if ((unique_id_1 + unique_id_2) % 2 == 0) return true;
1014      } else {
1015 <      if ((unique_id_1 + unique_id_2) % 2 == 1) return true;
1015 >      if ((unique_id_1 + unique_id_2) % 2 == 1) return true;
1016      }
755 – #else
756 –    // in the normal loop, the atom numbers are unique
757 –    unique_id_1 = atom1;
758 –    unique_id_2 = atom2;
1017   #endif
1018      
1019 <    for (vector<int>::iterator i = skipsForAtom[atom1].begin();
1020 <         i != skipsForAtom[atom1].end(); ++i) {
1021 <      if ( (*i) == unique_id_2 ) return true;
1019 >    return false;
1020 >  }
1021 >
1022 >  /**
1023 >   * We need to handle the interactions for atoms who are involved in
1024 >   * the same rigid body as well as some short range interactions
1025 >   * (bonds, bends, torsions) differently from other interactions.
1026 >   * We'll still visit the pairwise routines, but with a flag that
1027 >   * tells those routines to exclude the pair from direct long range
1028 >   * interactions.  Some indirect interactions (notably reaction
1029 >   * field) must still be handled for these pairs.
1030 >   */
1031 >  bool ForceMatrixDecomposition::excludeAtomPair(int atom1, int atom2) {
1032 >
1033 >    // excludesForAtom was constructed to use row/column indices in the MPI
1034 >    // version, and to use local IDs in the non-MPI version:
1035 >    
1036 >    for (vector<int>::iterator i = excludesForAtom[atom1].begin();
1037 >         i != excludesForAtom[atom1].end(); ++i) {
1038 >      if ( (*i) == atom2 ) return true;
1039      }
1040  
1041      return false;
# Line 785 | Line 1060 | namespace OpenMD {
1060  
1061      // filling interaction blocks with pointers
1062    void ForceMatrixDecomposition::fillInteractionData(InteractionData &idat,
1063 <                                                     int atom1, int atom2) {    
1063 >                                                     int atom1, int atom2) {
1064 >
1065 >    idat.excluded = excludeAtomPair(atom1, atom2);
1066 >  
1067   #ifdef IS_MPI
1068 +    idat.atypes = make_pair( atypesRow[atom1], atypesCol[atom2]);
1069 +    //idat.atypes = make_pair( ff_->getAtomType(identsRow[atom1]),
1070 +    //                         ff_->getAtomType(identsCol[atom2]) );
1071      
791 –    idat.atypes = make_pair( ff_->getAtomType(identsRow[atom1]),
792 –                             ff_->getAtomType(identsCol[atom2]) );
793 –    
1072      if (storageLayout_ & DataStorage::dslAmat) {
1073        idat.A1 = &(atomRowData.aMat[atom1]);
1074        idat.A2 = &(atomColData.aMat[atom2]);
# Line 826 | Line 1104 | namespace OpenMD {
1104        idat.particlePot2 = &(atomColData.particlePot[atom2]);
1105      }
1106  
1107 +    if (storageLayout_ & DataStorage::dslSkippedCharge) {              
1108 +      idat.skippedCharge1 = &(atomRowData.skippedCharge[atom1]);
1109 +      idat.skippedCharge2 = &(atomColData.skippedCharge[atom2]);
1110 +    }
1111 +
1112 +    if (storageLayout_ & DataStorage::dslFlucQPosition) {              
1113 +      idat.flucQ1 = &(atomRowData.flucQPos[atom1]);
1114 +      idat.flucQ2 = &(atomColData.flucQPos[atom2]);
1115 +    }
1116 +
1117   #else
1118 +    
1119  
1120 <    idat.atypes = make_pair( ff_->getAtomType(idents[atom1]),
1121 <                             ff_->getAtomType(idents[atom2]) );
1120 >    // cerr << "atoms = " << atom1 << " " << atom2 << "\n";
1121 >    // cerr << "pos1 = " << snap_->atomData.position[atom1] << "\n";
1122 >    // cerr << "pos2 = " << snap_->atomData.position[atom2] << "\n";
1123  
1124 +    idat.atypes = make_pair( atypesLocal[atom1], atypesLocal[atom2]);
1125 +    //idat.atypes = make_pair( ff_->getAtomType(idents[atom1]),
1126 +    //                         ff_->getAtomType(idents[atom2]) );
1127 +
1128      if (storageLayout_ & DataStorage::dslAmat) {
1129        idat.A1 = &(snap_->atomData.aMat[atom1]);
1130        idat.A2 = &(snap_->atomData.aMat[atom2]);
# Line 866 | Line 1160 | namespace OpenMD {
1160        idat.particlePot2 = &(snap_->atomData.particlePot[atom2]);
1161      }
1162  
1163 +    if (storageLayout_ & DataStorage::dslSkippedCharge) {
1164 +      idat.skippedCharge1 = &(snap_->atomData.skippedCharge[atom1]);
1165 +      idat.skippedCharge2 = &(snap_->atomData.skippedCharge[atom2]);
1166 +    }
1167 +
1168 +    if (storageLayout_ & DataStorage::dslFlucQPosition) {              
1169 +      idat.flucQ1 = &(snap_->atomData.flucQPos[atom1]);
1170 +      idat.flucQ2 = &(snap_->atomData.flucQPos[atom2]);
1171 +    }
1172 +
1173   #endif
1174    }
1175  
1176    
1177    void ForceMatrixDecomposition::unpackInteractionData(InteractionData &idat, int atom1, int atom2) {    
1178   #ifdef IS_MPI
1179 <    pot_row[atom1] += 0.5 *  *(idat.pot);
1180 <    pot_col[atom2] += 0.5 *  *(idat.pot);
1179 >    pot_row[atom1] += RealType(0.5) *  *(idat.pot);
1180 >    pot_col[atom2] += RealType(0.5) *  *(idat.pot);
1181  
1182      atomRowData.force[atom1] += *(idat.f1);
1183      atomColData.force[atom2] -= *(idat.f1);
1184 +
1185 +    if (storageLayout_ & DataStorage::dslFlucQForce) {              
1186 +      atomRowData.flucQFrc[atom1] -= *(idat.dVdFQ1);
1187 +      atomColData.flucQFrc[atom2] -= *(idat.dVdFQ2);
1188 +    }
1189 +
1190 +    if (storageLayout_ & DataStorage::dslElectricField) {              
1191 +      atomRowData.electricField[atom1] += *(idat.eField1);
1192 +      atomColData.electricField[atom2] += *(idat.eField2);
1193 +    }
1194 +
1195   #else
1196      pairwisePot += *(idat.pot);
1197  
1198      snap_->atomData.force[atom1] += *(idat.f1);
1199      snap_->atomData.force[atom2] -= *(idat.f1);
885 – #endif
886 –    
887 –  }
1200  
1201 <
1202 <  void ForceMatrixDecomposition::fillSkipData(InteractionData &idat,
1203 <                                              int atom1, int atom2) {
1204 < #ifdef IS_MPI
1205 <    idat.atypes = make_pair( ff_->getAtomType(identsRow[atom1]),
1206 <                             ff_->getAtomType(identsCol[atom2]) );
1207 <
896 <    if (storageLayout_ & DataStorage::dslElectroFrame) {
897 <      idat.eFrame1 = &(atomRowData.electroFrame[atom1]);
898 <      idat.eFrame2 = &(atomColData.electroFrame[atom2]);
1201 >    if (idat.doParticlePot) {
1202 >      // This is the pairwise contribution to the particle pot.  The
1203 >      // embedding contribution is added in each of the low level
1204 >      // non-bonded routines.  In parallel, this calculation is done
1205 >      // in collectData, not in unpackInteractionData.
1206 >      snap_->atomData.particlePot[atom1] += *(idat.vpair) * *(idat.sw);
1207 >      snap_->atomData.particlePot[atom2] += *(idat.vpair) * *(idat.sw);
1208      }
1209 <
1210 <    if (storageLayout_ & DataStorage::dslTorque) {
1211 <      idat.t1 = &(atomRowData.torque[atom1]);
1212 <      idat.t2 = &(atomColData.torque[atom2]);
1209 >    
1210 >    if (storageLayout_ & DataStorage::dslFlucQForce) {              
1211 >      snap_->atomData.flucQFrc[atom1] -= *(idat.dVdFQ1);
1212 >      snap_->atomData.flucQFrc[atom2] -= *(idat.dVdFQ2);
1213      }
1214  
1215 <    if (storageLayout_ & DataStorage::dslSkippedCharge) {
1216 <      idat.skippedCharge1 = &(atomRowData.skippedCharge[atom1]);
1217 <      idat.skippedCharge2 = &(atomColData.skippedCharge[atom2]);
1215 >    if (storageLayout_ & DataStorage::dslElectricField) {              
1216 >      snap_->atomData.electricField[atom1] += *(idat.eField1);
1217 >      snap_->atomData.electricField[atom2] += *(idat.eField2);
1218      }
910 – #else
911 –    idat.atypes = make_pair( ff_->getAtomType(idents[atom1]),
912 –                             ff_->getAtomType(idents[atom2]) );
1219  
914 –    if (storageLayout_ & DataStorage::dslElectroFrame) {
915 –      idat.eFrame1 = &(snap_->atomData.electroFrame[atom1]);
916 –      idat.eFrame2 = &(snap_->atomData.electroFrame[atom2]);
917 –    }
918 –
919 –    if (storageLayout_ & DataStorage::dslTorque) {
920 –      idat.t1 = &(snap_->atomData.torque[atom1]);
921 –      idat.t2 = &(snap_->atomData.torque[atom2]);
922 –    }
923 –
924 –    if (storageLayout_ & DataStorage::dslSkippedCharge) {
925 –      idat.skippedCharge1 = &(snap_->atomData.skippedCharge[atom1]);
926 –      idat.skippedCharge2 = &(snap_->atomData.skippedCharge[atom2]);
927 –    }
928 – #endif    
929 –  }
930 –
931 –
932 –  void ForceMatrixDecomposition::unpackSkipData(InteractionData &idat, int atom1, int atom2) {    
933 – #ifdef IS_MPI
934 –    pot_row[atom1] += 0.5 *  *(idat.pot);
935 –    pot_col[atom2] += 0.5 *  *(idat.pot);
936 – #else
937 –    pairwisePot += *(idat.pot);  
1220   #endif
1221 <
1221 >    
1222    }
1223  
942 –
1224    /*
1225     * buildNeighborList
1226     *
# Line 950 | Line 1231 | namespace OpenMD {
1231        
1232      vector<pair<int, int> > neighborList;
1233      groupCutoffs cuts;
1234 +    bool doAllPairs = false;
1235 +
1236   #ifdef IS_MPI
1237      cellListRow_.clear();
1238      cellListCol_.clear();
# Line 969 | Line 1252 | namespace OpenMD {
1252      nCells_.y() = (int) ( Hy.length() )/ rList_;
1253      nCells_.z() = (int) ( Hz.length() )/ rList_;
1254  
1255 +    // handle small boxes where the cell offsets can end up repeating cells
1256 +    
1257 +    if (nCells_.x() < 3) doAllPairs = true;
1258 +    if (nCells_.y() < 3) doAllPairs = true;
1259 +    if (nCells_.z() < 3) doAllPairs = true;
1260 +
1261      Mat3x3d invHmat = snap_->getInvHmat();
1262      Vector3d rs, scaled, dr;
1263      Vector3i whichCell;
# Line 982 | Line 1271 | namespace OpenMD {
1271      cellList_.resize(nCtot);
1272   #endif
1273  
1274 +    if (!doAllPairs) {
1275   #ifdef IS_MPI
986 –    for (int i = 0; i < nGroupsInRow_; i++) {
987 –      rs = cgRowData.position[i];
1276  
1277 <      // scaled positions relative to the box vectors
1278 <      scaled = invHmat * rs;
1279 <
1280 <      // wrap the vector back into the unit box by subtracting integer box
1281 <      // numbers
1282 <      for (int j = 0; j < 3; j++) {
1283 <        scaled[j] -= roundMe(scaled[j]);
1284 <        scaled[j] += 0.5;
1277 >      for (int i = 0; i < nGroupsInRow_; i++) {
1278 >        rs = cgRowData.position[i];
1279 >        
1280 >        // scaled positions relative to the box vectors
1281 >        scaled = invHmat * rs;
1282 >        
1283 >        // wrap the vector back into the unit box by subtracting integer box
1284 >        // numbers
1285 >        for (int j = 0; j < 3; j++) {
1286 >          scaled[j] -= roundMe(scaled[j]);
1287 >          scaled[j] += 0.5;
1288 >        }
1289 >        
1290 >        // find xyz-indices of cell that cutoffGroup is in.
1291 >        whichCell.x() = nCells_.x() * scaled.x();
1292 >        whichCell.y() = nCells_.y() * scaled.y();
1293 >        whichCell.z() = nCells_.z() * scaled.z();
1294 >        
1295 >        // find single index of this cell:
1296 >        cellIndex = Vlinear(whichCell, nCells_);
1297 >        
1298 >        // add this cutoff group to the list of groups in this cell;
1299 >        cellListRow_[cellIndex].push_back(i);
1300        }
1301 <    
1302 <      // find xyz-indices of cell that cutoffGroup is in.
1303 <      whichCell.x() = nCells_.x() * scaled.x();
1304 <      whichCell.y() = nCells_.y() * scaled.y();
1305 <      whichCell.z() = nCells_.z() * scaled.z();
1306 <
1307 <      // find single index of this cell:
1308 <      cellIndex = Vlinear(whichCell, nCells_);
1309 <
1310 <      // add this cutoff group to the list of groups in this cell;
1311 <      cellListRow_[cellIndex].push_back(i);
1312 <    }
1313 <
1314 <    for (int i = 0; i < nGroupsInCol_; i++) {
1315 <      rs = cgColData.position[i];
1316 <
1317 <      // scaled positions relative to the box vectors
1318 <      scaled = invHmat * rs;
1319 <
1320 <      // wrap the vector back into the unit box by subtracting integer box
1321 <      // numbers
1322 <      for (int j = 0; j < 3; j++) {
1323 <        scaled[j] -= roundMe(scaled[j]);
1021 <        scaled[j] += 0.5;
1301 >      for (int i = 0; i < nGroupsInCol_; i++) {
1302 >        rs = cgColData.position[i];
1303 >        
1304 >        // scaled positions relative to the box vectors
1305 >        scaled = invHmat * rs;
1306 >        
1307 >        // wrap the vector back into the unit box by subtracting integer box
1308 >        // numbers
1309 >        for (int j = 0; j < 3; j++) {
1310 >          scaled[j] -= roundMe(scaled[j]);
1311 >          scaled[j] += 0.5;
1312 >        }
1313 >        
1314 >        // find xyz-indices of cell that cutoffGroup is in.
1315 >        whichCell.x() = nCells_.x() * scaled.x();
1316 >        whichCell.y() = nCells_.y() * scaled.y();
1317 >        whichCell.z() = nCells_.z() * scaled.z();
1318 >        
1319 >        // find single index of this cell:
1320 >        cellIndex = Vlinear(whichCell, nCells_);
1321 >        
1322 >        // add this cutoff group to the list of groups in this cell;
1323 >        cellListCol_[cellIndex].push_back(i);
1324        }
1325 <
1024 <      // find xyz-indices of cell that cutoffGroup is in.
1025 <      whichCell.x() = nCells_.x() * scaled.x();
1026 <      whichCell.y() = nCells_.y() * scaled.y();
1027 <      whichCell.z() = nCells_.z() * scaled.z();
1028 <
1029 <      // find single index of this cell:
1030 <      cellIndex = Vlinear(whichCell, nCells_);
1031 <
1032 <      // add this cutoff group to the list of groups in this cell;
1033 <      cellListCol_[cellIndex].push_back(i);
1034 <    }
1325 >    
1326   #else
1327 <    for (int i = 0; i < nGroups_; i++) {
1328 <      rs = snap_->cgData.position[i];
1329 <
1330 <      // scaled positions relative to the box vectors
1331 <      scaled = invHmat * rs;
1332 <
1333 <      // wrap the vector back into the unit box by subtracting integer box
1334 <      // numbers
1335 <      for (int j = 0; j < 3; j++) {
1336 <        scaled[j] -= roundMe(scaled[j]);
1337 <        scaled[j] += 0.5;
1327 >      for (int i = 0; i < nGroups_; i++) {
1328 >        rs = snap_->cgData.position[i];
1329 >        
1330 >        // scaled positions relative to the box vectors
1331 >        scaled = invHmat * rs;
1332 >        
1333 >        // wrap the vector back into the unit box by subtracting integer box
1334 >        // numbers
1335 >        for (int j = 0; j < 3; j++) {
1336 >          scaled[j] -= roundMe(scaled[j]);
1337 >          scaled[j] += 0.5;
1338 >        }
1339 >        
1340 >        // find xyz-indices of cell that cutoffGroup is in.
1341 >        whichCell.x() = nCells_.x() * scaled.x();
1342 >        whichCell.y() = nCells_.y() * scaled.y();
1343 >        whichCell.z() = nCells_.z() * scaled.z();
1344 >        
1345 >        // find single index of this cell:
1346 >        cellIndex = Vlinear(whichCell, nCells_);
1347 >        
1348 >        // add this cutoff group to the list of groups in this cell;
1349 >        cellList_[cellIndex].push_back(i);
1350        }
1351  
1049 –      // find xyz-indices of cell that cutoffGroup is in.
1050 –      whichCell.x() = nCells_.x() * scaled.x();
1051 –      whichCell.y() = nCells_.y() * scaled.y();
1052 –      whichCell.z() = nCells_.z() * scaled.z();
1053 –
1054 –      // find single index of this cell:
1055 –      cellIndex = Vlinear(whichCell, nCells_);      
1056 –
1057 –      // add this cutoff group to the list of groups in this cell;
1058 –      cellList_[cellIndex].push_back(i);
1059 –    }
1352   #endif
1353  
1354 <    for (int m1z = 0; m1z < nCells_.z(); m1z++) {
1355 <      for (int m1y = 0; m1y < nCells_.y(); m1y++) {
1356 <        for (int m1x = 0; m1x < nCells_.x(); m1x++) {
1357 <          Vector3i m1v(m1x, m1y, m1z);
1358 <          int m1 = Vlinear(m1v, nCells_);
1067 <
1068 <          for (vector<Vector3i>::iterator os = cellOffsets_.begin();
1069 <               os != cellOffsets_.end(); ++os) {
1354 >      for (int m1z = 0; m1z < nCells_.z(); m1z++) {
1355 >        for (int m1y = 0; m1y < nCells_.y(); m1y++) {
1356 >          for (int m1x = 0; m1x < nCells_.x(); m1x++) {
1357 >            Vector3i m1v(m1x, m1y, m1z);
1358 >            int m1 = Vlinear(m1v, nCells_);
1359              
1360 <            Vector3i m2v = m1v + (*os);
1361 <            
1362 <            if (m2v.x() >= nCells_.x()) {
1363 <              m2v.x() = 0;          
1364 <            } else if (m2v.x() < 0) {
1076 <              m2v.x() = nCells_.x() - 1;
1077 <            }
1078 <            
1079 <            if (m2v.y() >= nCells_.y()) {
1080 <              m2v.y() = 0;          
1081 <            } else if (m2v.y() < 0) {
1082 <              m2v.y() = nCells_.y() - 1;
1083 <            }
1084 <            
1085 <            if (m2v.z() >= nCells_.z()) {
1086 <              m2v.z() = 0;          
1087 <            } else if (m2v.z() < 0) {
1088 <              m2v.z() = nCells_.z() - 1;
1089 <            }
1090 <            
1091 <            int m2 = Vlinear (m2v, nCells_);
1360 >            for (vector<Vector3i>::iterator os = cellOffsets_.begin();
1361 >                 os != cellOffsets_.end(); ++os) {
1362 >              
1363 >              Vector3i m2v = m1v + (*os);
1364 >            
1365  
1366 < #ifdef IS_MPI
1367 <            for (vector<int>::iterator j1 = cellListRow_[m1].begin();
1368 <                 j1 != cellListRow_[m1].end(); ++j1) {
1369 <              for (vector<int>::iterator j2 = cellListCol_[m2].begin();
1370 <                   j2 != cellListCol_[m2].end(); ++j2) {
1371 <                              
1372 <                // Always do this if we're in different cells or if
1373 <                // we're in the same cell and the global index of the
1374 <                // j2 cutoff group is less than the j1 cutoff group
1366 >              if (m2v.x() >= nCells_.x()) {
1367 >                m2v.x() = 0;          
1368 >              } else if (m2v.x() < 0) {
1369 >                m2v.x() = nCells_.x() - 1;
1370 >              }
1371 >              
1372 >              if (m2v.y() >= nCells_.y()) {
1373 >                m2v.y() = 0;          
1374 >              } else if (m2v.y() < 0) {
1375 >                m2v.y() = nCells_.y() - 1;
1376 >              }
1377 >              
1378 >              if (m2v.z() >= nCells_.z()) {
1379 >                m2v.z() = 0;          
1380 >              } else if (m2v.z() < 0) {
1381 >                m2v.z() = nCells_.z() - 1;
1382 >              }
1383  
1384 <                if (m2 != m1 || cgColToGlobal[(*j2)] < cgRowToGlobal[(*j1)]) {
1384 >              int m2 = Vlinear (m2v, nCells_);
1385 >              
1386 > #ifdef IS_MPI
1387 >              for (vector<int>::iterator j1 = cellListRow_[m1].begin();
1388 >                   j1 != cellListRow_[m1].end(); ++j1) {
1389 >                for (vector<int>::iterator j2 = cellListCol_[m2].begin();
1390 >                     j2 != cellListCol_[m2].end(); ++j2) {
1391 >                  
1392 >                  // In parallel, we need to visit *all* pairs of row
1393 >                  // & column indicies and will divide labor in the
1394 >                  // force evaluation later.
1395                    dr = cgColData.position[(*j2)] - cgRowData.position[(*j1)];
1396                    snap_->wrapVector(dr);
1397                    cuts = getGroupCutoffs( (*j1), (*j2) );
1398                    if (dr.lengthSquare() < cuts.third) {
1399                      neighborList.push_back(make_pair((*j1), (*j2)));
1400 <                  }
1400 >                  }                  
1401                  }
1402                }
1112 –            }
1403   #else
1404 +              for (vector<int>::iterator j1 = cellList_[m1].begin();
1405 +                   j1 != cellList_[m1].end(); ++j1) {
1406 +                for (vector<int>::iterator j2 = cellList_[m2].begin();
1407 +                     j2 != cellList_[m2].end(); ++j2) {
1408 +    
1409 +                  // Always do this if we're in different cells or if
1410 +                  // we're in the same cell and the global index of
1411 +                  // the j2 cutoff group is greater than or equal to
1412 +                  // the j1 cutoff group.  Note that Rappaport's code
1413 +                  // has a "less than" conditional here, but that
1414 +                  // deals with atom-by-atom computation.  OpenMD
1415 +                  // allows atoms within a single cutoff group to
1416 +                  // interact with each other.
1417  
1115 –            for (vector<int>::iterator j1 = cellList_[m1].begin();
1116 –                 j1 != cellList_[m1].end(); ++j1) {
1117 –              for (vector<int>::iterator j2 = cellList_[m2].begin();
1118 –                   j2 != cellList_[m2].end(); ++j2) {
1418  
1120 –                // Always do this if we're in different cells or if
1121 –                // we're in the same cell and the global index of the
1122 –                // j2 cutoff group is less than the j1 cutoff group
1419  
1420 <                if (m2 != m1 || (*j2) < (*j1)) {
1421 <                  dr = snap_->cgData.position[(*j2)] - snap_->cgData.position[(*j1)];
1422 <                  snap_->wrapVector(dr);
1423 <                  cuts = getGroupCutoffs( (*j1), (*j2) );
1424 <                  if (dr.lengthSquare() < cuts.third) {
1425 <                    neighborList.push_back(make_pair((*j1), (*j2)));
1420 >                  if (m2 != m1 || (*j2) >= (*j1) ) {
1421 >
1422 >                    dr = snap_->cgData.position[(*j2)] - snap_->cgData.position[(*j1)];
1423 >                    snap_->wrapVector(dr);
1424 >                    cuts = getGroupCutoffs( (*j1), (*j2) );
1425 >                    if (dr.lengthSquare() < cuts.third) {
1426 >                      neighborList.push_back(make_pair((*j1), (*j2)));
1427 >                    }
1428                    }
1429                  }
1430                }
1133 –            }
1431   #endif
1432 +            }
1433            }
1434          }
1435        }
1436 +    } else {
1437 +      // branch to do all cutoff group pairs
1438 + #ifdef IS_MPI
1439 +      for (int j1 = 0; j1 < nGroupsInRow_; j1++) {
1440 +        for (int j2 = 0; j2 < nGroupsInCol_; j2++) {    
1441 +          dr = cgColData.position[j2] - cgRowData.position[j1];
1442 +          snap_->wrapVector(dr);
1443 +          cuts = getGroupCutoffs( j1, j2 );
1444 +          if (dr.lengthSquare() < cuts.third) {
1445 +            neighborList.push_back(make_pair(j1, j2));
1446 +          }
1447 +        }
1448 +      }      
1449 + #else
1450 +      // include all groups here.
1451 +      for (int j1 = 0; j1 < nGroups_; j1++) {
1452 +        // include self group interactions j2 == j1
1453 +        for (int j2 = j1; j2 < nGroups_; j2++) {
1454 +          dr = snap_->cgData.position[j2] - snap_->cgData.position[j1];
1455 +          snap_->wrapVector(dr);
1456 +          cuts = getGroupCutoffs( j1, j2 );
1457 +          if (dr.lengthSquare() < cuts.third) {
1458 +            neighborList.push_back(make_pair(j1, j2));
1459 +          }
1460 +        }    
1461 +      }
1462 + #endif
1463      }
1464 <    
1464 >      
1465      // save the local cutoff group positions for the check that is
1466      // done on each loop:
1467      saved_CG_positions_.clear();
1468      for (int i = 0; i < nGroups_; i++)
1469        saved_CG_positions_.push_back(snap_->cgData.position[i]);
1470 <  
1470 >    
1471      return neighborList;
1472    }
1473   } //end namespace OpenMD

Diff Legend

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