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 1589 by gezelter, Sun Jul 10 16:05:34 2011 UTC vs.
Revision 1601 by gezelter, Thu Aug 4 20:04:35 2011 UTC

# Line 47 | Line 47 | namespace OpenMD {
47   using namespace std;
48   namespace OpenMD {
49  
50 +  ForceMatrixDecomposition::ForceMatrixDecomposition(SimInfo* info, InteractionManager* iMan) : ForceDecomposition(info, iMan) {
51 +
52 +    // In a parallel computation, row and colum scans must visit all
53 +    // surrounding cells (not just the 14 upper triangular blocks that
54 +    // are used when the processor can see all pairs)
55 + #ifdef IS_MPI
56 +    cellOffsets_.push_back( Vector3i(-1, 0, 0) );
57 +    cellOffsets_.push_back( Vector3i(-1,-1, 0) );
58 +    cellOffsets_.push_back( Vector3i( 0,-1, 0) );
59 +    cellOffsets_.push_back( Vector3i( 1,-1, 0) );
60 +    cellOffsets_.push_back( Vector3i( 0, 0,-1) );
61 +    cellOffsets_.push_back( Vector3i(-1, 0, 1) );
62 +    cellOffsets_.push_back( Vector3i(-1,-1,-1) );
63 +    cellOffsets_.push_back( Vector3i( 0,-1,-1) );
64 +    cellOffsets_.push_back( Vector3i( 1,-1,-1) );
65 +    cellOffsets_.push_back( Vector3i( 1, 0,-1) );
66 +    cellOffsets_.push_back( Vector3i( 1, 1,-1) );
67 +    cellOffsets_.push_back( Vector3i( 0, 1,-1) );
68 +    cellOffsets_.push_back( Vector3i(-1, 1,-1) );
69 + #endif    
70 +  }
71 +
72 +
73    /**
74     * distributeInitialData is essentially a copy of the older fortran
75     * SimulationSetup
76     */
54 –  
77    void ForceMatrixDecomposition::distributeInitialData() {
78      snap_ = sman_->getCurrentSnapshot();
79      storageLayout_ = sman_->getStorageLayout();
# Line 74 | Line 96 | namespace OpenMD {
96  
97   #ifdef IS_MPI
98  
99 <    AtomCommIntRow = new Communicator<Row,int>(nLocal_);
100 <    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_);
99 >    MPI::Intracomm row = rowComm.getComm();
100 >    MPI::Intracomm col = colComm.getComm();
101  
102 <    AtomCommIntColumn = new Communicator<Column,int>(nLocal_);
103 <    AtomCommRealColumn = new Communicator<Column,RealType>(nLocal_);
104 <    AtomCommVectorColumn = new Communicator<Column,Vector3d>(nLocal_);
105 <    AtomCommMatrixColumn = new Communicator<Column,Mat3x3d>(nLocal_);
106 <    AtomCommPotColumn = new Communicator<Column,potVec>(nLocal_);
102 >    AtomPlanIntRow = new Plan<int>(row, nLocal_);
103 >    AtomPlanRealRow = new Plan<RealType>(row, nLocal_);
104 >    AtomPlanVectorRow = new Plan<Vector3d>(row, nLocal_);
105 >    AtomPlanMatrixRow = new Plan<Mat3x3d>(row, nLocal_);
106 >    AtomPlanPotRow = new Plan<potVec>(row, nLocal_);
107  
108 <    cgCommIntRow = new Communicator<Row,int>(nGroups_);
109 <    cgCommVectorRow = new Communicator<Row,Vector3d>(nGroups_);
110 <    cgCommIntColumn = new Communicator<Column,int>(nGroups_);
111 <    cgCommVectorColumn = new Communicator<Column,Vector3d>(nGroups_);
108 >    AtomPlanIntColumn = new Plan<int>(col, nLocal_);
109 >    AtomPlanRealColumn = new Plan<RealType>(col, nLocal_);
110 >    AtomPlanVectorColumn = new Plan<Vector3d>(col, nLocal_);
111 >    AtomPlanMatrixColumn = new Plan<Mat3x3d>(col, nLocal_);
112 >    AtomPlanPotColumn = new Plan<potVec>(col, nLocal_);
113  
114 <    nAtomsInRow_ = AtomCommIntRow->getSize();
115 <    nAtomsInCol_ = AtomCommIntColumn->getSize();
116 <    nGroupsInRow_ = cgCommIntRow->getSize();
117 <    nGroupsInCol_ = cgCommIntColumn->getSize();
114 >    cgPlanIntRow = new Plan<int>(row, nGroups_);
115 >    cgPlanVectorRow = new Plan<Vector3d>(row, nGroups_);
116 >    cgPlanIntColumn = new Plan<int>(col, nGroups_);
117 >    cgPlanVectorColumn = new Plan<Vector3d>(col, nGroups_);
118  
119 +    nAtomsInRow_ = AtomPlanIntRow->getSize();
120 +    nAtomsInCol_ = AtomPlanIntColumn->getSize();
121 +    nGroupsInRow_ = cgPlanIntRow->getSize();
122 +    nGroupsInCol_ = cgPlanIntColumn->getSize();
123 +
124      // Modify the data storage objects with the correct layouts and sizes:
125      atomRowData.resize(nAtomsInRow_);
126      atomRowData.setStorageLayout(storageLayout_);
# Line 109 | Line 134 | namespace OpenMD {
134      identsRow.resize(nAtomsInRow_);
135      identsCol.resize(nAtomsInCol_);
136      
137 <    AtomCommIntRow->gather(idents, identsRow);
138 <    AtomCommIntColumn->gather(idents, identsCol);
137 >    AtomPlanIntRow->gather(idents, identsRow);
138 >    AtomPlanIntColumn->gather(idents, identsCol);
139      
140      // allocate memory for the parallel objects
141 +    atypesRow.resize(nAtomsInRow_);
142 +    atypesCol.resize(nAtomsInCol_);
143 +
144 +    for (int i = 0; i < nAtomsInRow_; i++)
145 +      atypesRow[i] = ff_->getAtomType(identsRow[i]);
146 +    for (int i = 0; i < nAtomsInCol_; i++)
147 +      atypesCol[i] = ff_->getAtomType(identsCol[i]);        
148 +
149 +    pot_row.resize(nAtomsInRow_);
150 +    pot_col.resize(nAtomsInCol_);
151 +
152      AtomRowToGlobal.resize(nAtomsInRow_);
153      AtomColToGlobal.resize(nAtomsInCol_);
154 +    AtomPlanIntRow->gather(AtomLocalToGlobal, AtomRowToGlobal);
155 +    AtomPlanIntColumn->gather(AtomLocalToGlobal, AtomColToGlobal);
156 +
157      cgRowToGlobal.resize(nGroupsInRow_);
158      cgColToGlobal.resize(nGroupsInCol_);
159 +    cgPlanIntRow->gather(cgLocalToGlobal, cgRowToGlobal);
160 +    cgPlanIntColumn->gather(cgLocalToGlobal, cgColToGlobal);
161 +
162      massFactorsRow.resize(nAtomsInRow_);
163      massFactorsCol.resize(nAtomsInCol_);
164 <    pot_row.resize(nAtomsInRow_);
165 <    pot_col.resize(nAtomsInCol_);
164 >    AtomPlanRealRow->gather(massFactors, massFactorsRow);
165 >    AtomPlanRealColumn->gather(massFactors, massFactorsCol);
166  
125 –    AtomCommIntRow->gather(AtomLocalToGlobal, AtomRowToGlobal);
126 –    AtomCommIntColumn->gather(AtomLocalToGlobal, AtomColToGlobal);
127 –    
128 –    cgCommIntRow->gather(cgLocalToGlobal, cgRowToGlobal);
129 –    cgCommIntColumn->gather(cgLocalToGlobal, cgColToGlobal);
130 –
131 –    AtomCommRealRow->gather(massFactors, massFactorsRow);
132 –    AtomCommRealColumn->gather(massFactors, massFactorsCol);
133 –
167      groupListRow_.clear();
168      groupListRow_.resize(nGroupsInRow_);
169      for (int i = 0; i < nGroupsInRow_; i++) {
# Line 187 | Line 220 | namespace OpenMD {
220  
221   #endif
222  
223 +    // allocate memory for the parallel objects
224 +    atypesLocal.resize(nLocal_);
225 +
226 +    for (int i = 0; i < nLocal_; i++)
227 +      atypesLocal[i] = ff_->getAtomType(idents[i]);
228 +
229      groupList_.clear();
230      groupList_.resize(nGroups_);
231      for (int i = 0; i < nGroups_; i++) {
# Line 239 | Line 278 | namespace OpenMD {
278    void ForceMatrixDecomposition::createGtypeCutoffMap() {
279      
280      RealType tol = 1e-6;
281 +    largestRcut_ = 0.0;
282      RealType rc;
283      int atid;
284      set<AtomType*> atypes = info_->getSimulatedAtomTypes();
285 +    
286      map<int, RealType> atypeCutoff;
287        
288      for (set<AtomType*>::iterator at = atypes.begin();
# Line 249 | Line 290 | namespace OpenMD {
290        atid = (*at)->getIdent();
291        if (userChoseCutoff_)
292          atypeCutoff[atid] = userCutoff_;
293 <      else
293 >      else
294          atypeCutoff[atid] = interactionMan_->getSuggestedCutoffRadius(*at);
295      }
296 <
296 >    
297      vector<RealType> gTypeCutoffs;
298      // first we do a single loop over the cutoff groups to find the
299      // largest cutoff for any atypes present in this group.
# Line 312 | Line 353 | namespace OpenMD {
353      vector<RealType> groupCutoff(nGroups_, 0.0);
354      groupToGtype.resize(nGroups_);
355      for (int cg1 = 0; cg1 < nGroups_; cg1++) {
315 –
356        groupCutoff[cg1] = 0.0;
357        vector<int> atomList = getAtomsInGroupRow(cg1);
318 –
358        for (vector<int>::iterator ia = atomList.begin();
359             ia != atomList.end(); ++ia) {            
360          int atom1 = (*ia);
361          atid = idents[atom1];
362 <        if (atypeCutoff[atid] > groupCutoff[cg1]) {
362 >        if (atypeCutoff[atid] > groupCutoff[cg1])
363            groupCutoff[cg1] = atypeCutoff[atid];
325 –        }
364        }
365 <
365 >      
366        bool gTypeFound = false;
367        for (int gt = 0; gt < gTypeCutoffs.size(); gt++) {
368          if (abs(groupCutoff[cg1] - gTypeCutoffs[gt]) < tol) {
# Line 332 | Line 370 | namespace OpenMD {
370            gTypeFound = true;
371          }
372        }
373 <      if (!gTypeFound) {
373 >      if (!gTypeFound) {      
374          gTypeCutoffs.push_back( groupCutoff[cg1] );
375          groupToGtype[cg1] = gTypeCutoffs.size() - 1;
376        }      
# Line 341 | Line 379 | namespace OpenMD {
379  
380      // Now we find the maximum group cutoff value present in the simulation
381  
382 <    RealType groupMax = *max_element(gTypeCutoffs.begin(), gTypeCutoffs.end());
382 >    RealType groupMax = *max_element(gTypeCutoffs.begin(),
383 >                                     gTypeCutoffs.end());
384  
385   #ifdef IS_MPI
386 <    MPI::COMM_WORLD.Allreduce(&groupMax, &groupMax, 1, MPI::REALTYPE, MPI::MAX);
386 >    MPI::COMM_WORLD.Allreduce(&groupMax, &groupMax, 1, MPI::REALTYPE,
387 >                              MPI::MAX);
388   #endif
389      
390      RealType tradRcut = groupMax;
# Line 374 | Line 414 | namespace OpenMD {
414  
415          pair<int,int> key = make_pair(i,j);
416          gTypeCutoffMap[key].first = thisRcut;
377 –
417          if (thisRcut > largestRcut_) largestRcut_ = thisRcut;
379 –
418          gTypeCutoffMap[key].second = thisRcut*thisRcut;
381 –        
419          gTypeCutoffMap[key].third = pow(thisRcut + skinThickness_, 2);
383 –
420          // sanity check
421          
422          if (userChoseCutoff_) {
# Line 440 | Line 476 | namespace OpenMD {
476           Vector<RealType, N_INTERACTION_FAMILIES> (0.0));  
477  
478      if (storageLayout_ & DataStorage::dslParticlePot) {    
479 <      fill(atomRowData.particlePot.begin(), atomRowData.particlePot.end(), 0.0);
480 <      fill(atomColData.particlePot.begin(), atomColData.particlePot.end(), 0.0);
479 >      fill(atomRowData.particlePot.begin(), atomRowData.particlePot.end(),
480 >           0.0);
481 >      fill(atomColData.particlePot.begin(), atomColData.particlePot.end(),
482 >           0.0);
483      }
484  
485      if (storageLayout_ & DataStorage::dslDensity) {      
# Line 450 | Line 488 | namespace OpenMD {
488      }
489  
490      if (storageLayout_ & DataStorage::dslFunctional) {  
491 <      fill(atomRowData.functional.begin(), atomRowData.functional.end(), 0.0);
492 <      fill(atomColData.functional.begin(), atomColData.functional.end(), 0.0);
491 >      fill(atomRowData.functional.begin(), atomRowData.functional.end(),
492 >           0.0);
493 >      fill(atomColData.functional.begin(), atomColData.functional.end(),
494 >           0.0);
495      }
496  
497      if (storageLayout_ & DataStorage::dslFunctionalDerivative) {      
# Line 468 | Line 508 | namespace OpenMD {
508             atomColData.skippedCharge.end(), 0.0);
509      }
510  
511 < #else
512 <    
511 > #endif
512 >    // even in parallel, we need to zero out the local arrays:
513 >
514      if (storageLayout_ & DataStorage::dslParticlePot) {      
515        fill(snap_->atomData.particlePot.begin(),
516             snap_->atomData.particlePot.end(), 0.0);
# Line 491 | Line 532 | namespace OpenMD {
532        fill(snap_->atomData.skippedCharge.begin(),
533             snap_->atomData.skippedCharge.end(), 0.0);
534      }
494 – #endif
535      
536    }
537  
# Line 502 | Line 542 | namespace OpenMD {
542   #ifdef IS_MPI
543      
544      // gather up the atomic positions
545 <    AtomCommVectorRow->gather(snap_->atomData.position,
545 >    AtomPlanVectorRow->gather(snap_->atomData.position,
546                                atomRowData.position);
547 <    AtomCommVectorColumn->gather(snap_->atomData.position,
547 >    AtomPlanVectorColumn->gather(snap_->atomData.position,
548                                   atomColData.position);
549      
550      // gather up the cutoff group positions
551 <    cgCommVectorRow->gather(snap_->cgData.position,
551 >
552 >    cgPlanVectorRow->gather(snap_->cgData.position,
553                              cgRowData.position);
554 <    cgCommVectorColumn->gather(snap_->cgData.position,
554 >
555 >    cgPlanVectorColumn->gather(snap_->cgData.position,
556                                 cgColData.position);
557 +
558      
559      // if needed, gather the atomic rotation matrices
560      if (storageLayout_ & DataStorage::dslAmat) {
561 <      AtomCommMatrixRow->gather(snap_->atomData.aMat,
561 >      AtomPlanMatrixRow->gather(snap_->atomData.aMat,
562                                  atomRowData.aMat);
563 <      AtomCommMatrixColumn->gather(snap_->atomData.aMat,
563 >      AtomPlanMatrixColumn->gather(snap_->atomData.aMat,
564                                     atomColData.aMat);
565      }
566      
567      // if needed, gather the atomic eletrostatic frames
568      if (storageLayout_ & DataStorage::dslElectroFrame) {
569 <      AtomCommMatrixRow->gather(snap_->atomData.electroFrame,
569 >      AtomPlanMatrixRow->gather(snap_->atomData.electroFrame,
570                                  atomRowData.electroFrame);
571 <      AtomCommMatrixColumn->gather(snap_->atomData.electroFrame,
571 >      AtomPlanMatrixColumn->gather(snap_->atomData.electroFrame,
572                                     atomColData.electroFrame);
573      }
574 +
575   #endif      
576    }
577    
# Line 541 | Line 585 | namespace OpenMD {
585      
586      if (storageLayout_ & DataStorage::dslDensity) {
587        
588 <      AtomCommRealRow->scatter(atomRowData.density,
588 >      AtomPlanRealRow->scatter(atomRowData.density,
589                                 snap_->atomData.density);
590        
591        int n = snap_->atomData.density.size();
592        vector<RealType> rho_tmp(n, 0.0);
593 <      AtomCommRealColumn->scatter(atomColData.density, rho_tmp);
593 >      AtomPlanRealColumn->scatter(atomColData.density, rho_tmp);
594        for (int i = 0; i < n; i++)
595          snap_->atomData.density[i] += rho_tmp[i];
596      }
# Line 562 | Line 606 | namespace OpenMD {
606      storageLayout_ = sman_->getStorageLayout();
607   #ifdef IS_MPI
608      if (storageLayout_ & DataStorage::dslFunctional) {
609 <      AtomCommRealRow->gather(snap_->atomData.functional,
609 >      AtomPlanRealRow->gather(snap_->atomData.functional,
610                                atomRowData.functional);
611 <      AtomCommRealColumn->gather(snap_->atomData.functional,
611 >      AtomPlanRealColumn->gather(snap_->atomData.functional,
612                                   atomColData.functional);
613      }
614      
615      if (storageLayout_ & DataStorage::dslFunctionalDerivative) {
616 <      AtomCommRealRow->gather(snap_->atomData.functionalDerivative,
616 >      AtomPlanRealRow->gather(snap_->atomData.functionalDerivative,
617                                atomRowData.functionalDerivative);
618 <      AtomCommRealColumn->gather(snap_->atomData.functionalDerivative,
618 >      AtomPlanRealColumn->gather(snap_->atomData.functionalDerivative,
619                                   atomColData.functionalDerivative);
620      }
621   #endif
# Line 585 | Line 629 | namespace OpenMD {
629      int n = snap_->atomData.force.size();
630      vector<Vector3d> frc_tmp(n, V3Zero);
631      
632 <    AtomCommVectorRow->scatter(atomRowData.force, frc_tmp);
632 >    AtomPlanVectorRow->scatter(atomRowData.force, frc_tmp);
633      for (int i = 0; i < n; i++) {
634        snap_->atomData.force[i] += frc_tmp[i];
635        frc_tmp[i] = 0.0;
636      }
637      
638 <    AtomCommVectorColumn->scatter(atomColData.force, frc_tmp);
639 <    for (int i = 0; i < n; i++)
638 >    AtomPlanVectorColumn->scatter(atomColData.force, frc_tmp);
639 >    for (int i = 0; i < n; i++) {
640        snap_->atomData.force[i] += frc_tmp[i];
641 <    
642 <    
641 >    }
642 >        
643      if (storageLayout_ & DataStorage::dslTorque) {
644  
645        int nt = snap_->atomData.torque.size();
646        vector<Vector3d> trq_tmp(nt, V3Zero);
647  
648 <      AtomCommVectorRow->scatter(atomRowData.torque, trq_tmp);
648 >      AtomPlanVectorRow->scatter(atomRowData.torque, trq_tmp);
649        for (int i = 0; i < nt; i++) {
650          snap_->atomData.torque[i] += trq_tmp[i];
651          trq_tmp[i] = 0.0;
652        }
653        
654 <      AtomCommVectorColumn->scatter(atomColData.torque, trq_tmp);
654 >      AtomPlanVectorColumn->scatter(atomColData.torque, trq_tmp);
655        for (int i = 0; i < nt; i++)
656          snap_->atomData.torque[i] += trq_tmp[i];
657      }
# Line 617 | Line 661 | namespace OpenMD {
661        int ns = snap_->atomData.skippedCharge.size();
662        vector<RealType> skch_tmp(ns, 0.0);
663  
664 <      AtomCommRealRow->scatter(atomRowData.skippedCharge, skch_tmp);
664 >      AtomPlanRealRow->scatter(atomRowData.skippedCharge, skch_tmp);
665        for (int i = 0; i < ns; i++) {
666 <        snap_->atomData.skippedCharge[i] = skch_tmp[i];
666 >        snap_->atomData.skippedCharge[i] += skch_tmp[i];
667          skch_tmp[i] = 0.0;
668        }
669        
670 <      AtomCommRealColumn->scatter(atomColData.skippedCharge, skch_tmp);
670 >      AtomPlanRealColumn->scatter(atomColData.skippedCharge, skch_tmp);
671        for (int i = 0; i < ns; i++)
672          snap_->atomData.skippedCharge[i] += skch_tmp[i];
673      }
# Line 635 | Line 679 | namespace OpenMD {
679  
680      // scatter/gather pot_row into the members of my column
681            
682 <    AtomCommPotRow->scatter(pot_row, pot_temp);
682 >    AtomPlanPotRow->scatter(pot_row, pot_temp);
683  
684      for (int ii = 0;  ii < pot_temp.size(); ii++ )
685        pairwisePot += pot_temp[ii];
# Line 643 | Line 687 | namespace OpenMD {
687      fill(pot_temp.begin(), pot_temp.end(),
688           Vector<RealType, N_INTERACTION_FAMILIES> (0.0));
689        
690 <    AtomCommPotColumn->scatter(pot_col, pot_temp);    
690 >    AtomPlanPotColumn->scatter(pot_col, pot_temp);    
691      
692      for (int ii = 0;  ii < pot_temp.size(); ii++ )
693        pairwisePot += pot_temp[ii];    
694 +    
695 +    for (int ii = 0; ii < N_INTERACTION_FAMILIES; ii++) {
696 +      RealType ploc1 = pairwisePot[ii];
697 +      RealType ploc2 = 0.0;
698 +      MPI::COMM_WORLD.Allreduce(&ploc1, &ploc2, 1, MPI::REALTYPE, MPI::SUM);
699 +      pairwisePot[ii] = ploc2;
700 +    }
701 +
702   #endif
703  
704    }
# Line 759 | Line 811 | namespace OpenMD {
811     */
812    bool ForceMatrixDecomposition::skipAtomPair(int atom1, int atom2) {
813      int unique_id_1, unique_id_2;
814 <
814 >    
815   #ifdef IS_MPI
816      // in MPI, we have to look up the unique IDs for each atom
817      unique_id_1 = AtomRowToGlobal[atom1];
# Line 789 | Line 841 | namespace OpenMD {
841     */
842    bool ForceMatrixDecomposition::excludeAtomPair(int atom1, int atom2) {
843      int unique_id_2;
792 –    
844   #ifdef IS_MPI
845      // in MPI, we have to look up the unique IDs for the row atom.
846      unique_id_2 = AtomColToGlobal[atom2];
# Line 830 | Line 881 | namespace OpenMD {
881      idat.excluded = excludeAtomPair(atom1, atom2);
882    
883   #ifdef IS_MPI
884 +    idat.atypes = make_pair( atypesRow[atom1], atypesCol[atom2]);
885 +    //idat.atypes = make_pair( ff_->getAtomType(identsRow[atom1]),
886 +    //                         ff_->getAtomType(identsCol[atom2]) );
887      
834 –    idat.atypes = make_pair( ff_->getAtomType(identsRow[atom1]),
835 –                             ff_->getAtomType(identsCol[atom2]) );
836 –    
888      if (storageLayout_ & DataStorage::dslAmat) {
889        idat.A1 = &(atomRowData.aMat[atom1]);
890        idat.A2 = &(atomColData.aMat[atom2]);
# Line 876 | Line 927 | namespace OpenMD {
927  
928   #else
929  
930 <    idat.atypes = make_pair( ff_->getAtomType(idents[atom1]),
931 <                             ff_->getAtomType(idents[atom2]) );
930 >    idat.atypes = make_pair( atypesLocal[atom1], atypesLocal[atom2]);
931 >    //idat.atypes = make_pair( ff_->getAtomType(idents[atom1]),
932 >    //                         ff_->getAtomType(idents[atom2]) );
933  
934      if (storageLayout_ & DataStorage::dslAmat) {
935        idat.A1 = &(snap_->atomData.aMat[atom1]);
# Line 1015 | Line 1067 | namespace OpenMD {
1067          // add this cutoff group to the list of groups in this cell;
1068          cellListRow_[cellIndex].push_back(i);
1069        }
1018 –      
1070        for (int i = 0; i < nGroupsInCol_; i++) {
1071          rs = cgColData.position[i];
1072          
# Line 1060 | Line 1111 | namespace OpenMD {
1111          whichCell.z() = nCells_.z() * scaled.z();
1112          
1113          // find single index of this cell:
1114 <        cellIndex = Vlinear(whichCell, nCells_);      
1114 >        cellIndex = Vlinear(whichCell, nCells_);
1115          
1116          // add this cutoff group to the list of groups in this cell;
1117          cellList_[cellIndex].push_back(i);
# Line 1104 | Line 1155 | namespace OpenMD {
1155                  for (vector<int>::iterator j2 = cellListCol_[m2].begin();
1156                       j2 != cellListCol_[m2].end(); ++j2) {
1157                    
1158 <                  // Always do this if we're in different cells or if
1159 <                  // we're in the same cell and the global index of the
1160 <                  // j2 cutoff group is less than the j1 cutoff group
1161 <                  
1162 <                  if (m2 != m1 || cgColToGlobal[(*j2)] < cgRowToGlobal[(*j1)]) {
1163 <                    dr = cgColData.position[(*j2)] - cgRowData.position[(*j1)];
1164 <                    snap_->wrapVector(dr);
1165 <                    cuts = getGroupCutoffs( (*j1), (*j2) );
1115 <                    if (dr.lengthSquare() < cuts.third) {
1116 <                      neighborList.push_back(make_pair((*j1), (*j2)));
1117 <                    }
1118 <                  }
1158 >                  // In parallel, we need to visit *all* pairs of row &
1159 >                  // column indicies and will truncate later on.
1160 >                  dr = cgColData.position[(*j2)] - cgRowData.position[(*j1)];
1161 >                  snap_->wrapVector(dr);
1162 >                  cuts = getGroupCutoffs( (*j1), (*j2) );
1163 >                  if (dr.lengthSquare() < cuts.third) {
1164 >                    neighborList.push_back(make_pair((*j1), (*j2)));
1165 >                  }                  
1166                  }
1167                }
1168   #else

Diff Legend

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