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/ForceDecomposition.cpp (file contents):
Revision 1539 by gezelter, Fri Jan 14 22:31:31 2011 UTC vs.
Revision 1544 by gezelter, Fri Mar 18 19:31:52 2011 UTC

# Line 39 | Line 39
39   * [4]  Vardeman & Gezelter, in progress (2009).                        
40   */
41   #include "parallel/ForceDecomposition.hpp"
42 – #include "parallel/Communicator.hpp"
42   #include "math/SquareMatrix3.hpp"
43 + #include "nonbonded/NonBondedInteraction.hpp"
44 + #include "brains/SnapshotManager.hpp"
45  
46 + using namespace std;
47   namespace OpenMD {
48  
49 +  /**
50 +   * distributeInitialData is essentially a copy of the older fortran
51 +   * SimulationSetup
52 +   */
53 +  
54    void ForceDecomposition::distributeInitialData() {
55 < #ifdef IS_MPI
55 > #ifdef IS_MPI    
56 >    Snapshot* snap = sman_->getCurrentSnapshot();
57 >    int nLocal = snap->getNumberOfAtoms();
58 >    int nGroups = snap->getNumberOfCutoffGroups();
59  
60 <    int nAtoms;
61 <    int nGroups;
60 >    AtomCommIntI = new Communicator<Row,int>(nLocal);
61 >    AtomCommRealI = new Communicator<Row,RealType>(nLocal);
62 >    AtomCommVectorI = new Communicator<Row,Vector3d>(nLocal);
63 >    AtomCommMatrixI = new Communicator<Row,Mat3x3d>(nLocal);
64  
65 <    AtomCommRealI = new Comm<I,RealType>(nAtoms);
66 <    AtomCommVectorI = new Comm<I,Vector3d>(nAtoms);
67 <    AtomCommMatrixI = new Comm<I,Mat3x3d>(nAtoms);
65 >    AtomCommIntJ = new Communicator<Column,int>(nLocal);
66 >    AtomCommRealJ = new Communicator<Column,RealType>(nLocal);
67 >    AtomCommVectorJ = new Communicator<Column,Vector3d>(nLocal);
68 >    AtomCommMatrixJ = new Communicator<Column,Mat3x3d>(nLocal);
69  
70 <    AtomCommRealJ = new Comm<J,RealType>(nAtoms);
71 <    AtomCommVectorJ = new Comm<J,Vector3d>(nAtoms);
72 <    AtomCommMatrixJ = new Comm<J,Mat3x3d>(nAtoms);
70 >    cgCommIntI = new Communicator<Row,int>(nGroups);
71 >    cgCommVectorI = new Communicator<Row,Vector3d>(nGroups);
72 >    cgCommIntJ = new Communicator<Column,int>(nGroups);
73 >    cgCommVectorJ = new Communicator<Column,Vector3d>(nGroups);
74  
75 <    cgCommVectorI = new Comm<I,Vector3d>(nGroups);
76 <    cgCommVectorJ = new Comm<J,Vector3d>(nGroups);
77 <    // more to come
75 >    int nAtomsInRow = AtomCommIntI->getSize();
76 >    int nAtomsInCol = AtomCommIntJ->getSize();
77 >    int nGroupsInRow = cgCommIntI->getSize();
78 >    int nGroupsInCol = cgCommIntJ->getSize();
79 >
80 >    vector<vector<RealType> > pot_row(N_INTERACTION_FAMILIES,
81 >                                      vector<RealType> (nAtomsInRow, 0.0));
82 >    vector<vector<RealType> > pot_col(N_INTERACTION_FAMILIES,
83 >                                      vector<RealType> (nAtomsInCol, 0.0));
84 >    
85 >    vector<RealType> pot_local(N_INTERACTION_FAMILIES, 0.0);
86 >
87 >    // gather the information for atomtype IDs (atids):
88 >    AtomCommIntI->gather(info_->getIdentArray(), identsRow);
89 >    AtomCommIntJ->gather(info_->getIdentArray(), identsCol);
90 >
91 >    AtomLocalToGlobal = info_->getLocalToGlobalAtomIndex();
92 >    AtomCommIntI->gather(AtomLocalToGlobal, AtomRowToGlobal);
93 >    AtomCommIntJ->gather(AtomLocalToGlobal, AtomColToGlobal);
94 >
95 >    cgLocalToGlobal = info_->getLocalToGlobalCutoffGroupIndex();
96 >    cgCommIntI->gather(cgLocalToGlobal, cgRowToGlobal);
97 >    cgCommIntJ->gather(cgLocalToGlobal, cgColToGlobal);
98 >
99 >      
100 >      
101 >
102 >
103 >
104 >    // still need:
105 >    // topoDist
106 >    // exclude
107   #endif
108    }
109      
# Line 69 | Line 112 | namespace OpenMD {
112    void ForceDecomposition::distributeData()  {
113   #ifdef IS_MPI
114      Snapshot* snap = sman_->getCurrentSnapshot();
115 <
115 >    
116      // gather up the atomic positions
117      AtomCommVectorI->gather(snap->atomData.position,
118                              snap->atomIData.position);
119      AtomCommVectorJ->gather(snap->atomData.position,
120 <                           snap->atomJData.position);
120 >                            snap->atomJData.position);
121      
122      // gather up the cutoff group positions
123      cgCommVectorI->gather(snap->cgData.position,
124 <                         snap->cgIData.position);
124 >                          snap->cgIData.position);
125      cgCommVectorJ->gather(snap->cgData.position,
126 <                         snap->cgJData.position);
126 >                          snap->cgJData.position);
127      
128      // if needed, gather the atomic rotation matrices
129      if (snap->atomData.getStorageLayout() & DataStorage::dslAmat) {
130        AtomCommMatrixI->gather(snap->atomData.aMat,
131 <                             snap->atomIData.aMat);
131 >                              snap->atomIData.aMat);
132        AtomCommMatrixJ->gather(snap->atomData.aMat,
133 <                             snap->atomJData.aMat);
133 >                              snap->atomJData.aMat);
134      }
135      
136      // if needed, gather the atomic eletrostatic frames
137      if (snap->atomData.getStorageLayout() & DataStorage::dslElectroFrame) {
138        AtomCommMatrixI->gather(snap->atomData.electroFrame,
139 <                             snap->atomIData.electroFrame);
139 >                              snap->atomIData.electroFrame);
140        AtomCommMatrixJ->gather(snap->atomData.electroFrame,
141 <                             snap->atomJData.electroFrame);
141 >                              snap->atomJData.electroFrame);
142      }
143   #endif      
144    }
# Line 103 | Line 146 | namespace OpenMD {
146    void ForceDecomposition::collectIntermediateData() {
147   #ifdef IS_MPI
148      Snapshot* snap = sman_->getCurrentSnapshot();
106 –    // gather up the atomic positions
149      
150      if (snap->atomData.getStorageLayout() & DataStorage::dslDensity) {
151 +
152        AtomCommRealI->scatter(snap->atomIData.density,
153 <                            snap->atomData.density);
154 <      std::vector<RealType> rho_tmp;
155 <      int n = snap->getNumberOfAtoms();
156 <      rho_tmp.reserve( n );
153 >                             snap->atomData.density);
154 >
155 >      int n = snap->atomData.density.size();
156 >      std::vector<RealType> rho_tmp(n, 0.0);
157        AtomCommRealJ->scatter(snap->atomJData.density, rho_tmp);
158        for (int i = 0; i < n; i++)
159          snap->atomData.density[i] += rho_tmp[i];
# Line 123 | Line 166 | namespace OpenMD {
166      Snapshot* snap = sman_->getCurrentSnapshot();
167      if (snap->atomData.getStorageLayout() & DataStorage::dslFunctional) {
168        AtomCommRealI->gather(snap->atomData.functional,
169 <                           snap->atomIData.functional);
169 >                            snap->atomIData.functional);
170        AtomCommRealJ->gather(snap->atomData.functional,
171 <                           snap->atomJData.functional);
171 >                            snap->atomJData.functional);
172      }
173      
174      if (snap->atomData.getStorageLayout() & DataStorage::dslFunctionalDerivative) {
175        AtomCommRealI->gather(snap->atomData.functionalDerivative,
176 <                           snap->atomIData.functionalDerivative);
176 >                            snap->atomIData.functionalDerivative);
177        AtomCommRealJ->gather(snap->atomData.functionalDerivative,
178 <                           snap->atomJData.functionalDerivative);
178 >                            snap->atomJData.functionalDerivative);
179      }
180   #endif
181    }
# Line 140 | Line 183 | namespace OpenMD {
183    
184    void ForceDecomposition::collectData() {
185   #ifdef IS_MPI
186 +    Snapshot* snap = sman_->getCurrentSnapshot();
187 +    
188 +    int n = snap->atomData.force.size();
189 +    vector<Vector3d> frc_tmp(n, V3Zero);
190 +    
191 +    AtomCommVectorI->scatter(snap->atomIData.force, frc_tmp);
192 +    for (int i = 0; i < n; i++) {
193 +      snap->atomData.force[i] += frc_tmp[i];
194 +      frc_tmp[i] = 0.0;
195 +    }
196 +    
197 +    AtomCommVectorJ->scatter(snap->atomJData.force, frc_tmp);
198 +    for (int i = 0; i < n; i++)
199 +      snap->atomData.force[i] += frc_tmp[i];
200 +    
201 +    
202 +    if (snap->atomData.getStorageLayout() & DataStorage::dslTorque) {
203 +
204 +      int nt = snap->atomData.force.size();
205 +      vector<Vector3d> trq_tmp(nt, V3Zero);
206 +
207 +      AtomCommVectorI->scatter(snap->atomIData.torque, trq_tmp);
208 +      for (int i = 0; i < n; i++) {
209 +        snap->atomData.torque[i] += trq_tmp[i];
210 +        trq_tmp[i] = 0.0;
211 +      }
212 +      
213 +      AtomCommVectorJ->scatter(snap->atomJData.torque, trq_tmp);
214 +      for (int i = 0; i < n; i++)
215 +        snap->atomData.torque[i] += trq_tmp[i];
216 +    }
217 +    
218 +    int nLocal = snap->getNumberOfAtoms();
219 +
220 +    vector<vector<RealType> > pot_temp(N_INTERACTION_FAMILIES,
221 +                                       vector<RealType> (nLocal, 0.0));
222 +    
223 +    for (int i = 0; i < N_INTERACTION_FAMILIES; i++) {
224 +      AtomCommRealI->scatter(pot_row[i], pot_temp[i]);
225 +      for (int ii = 0;  ii < pot_temp[i].size(); ii++ ) {
226 +        pot_local[i] += pot_temp[i][ii];
227 +      }
228 +    }
229   #endif
230    }
231    

Diff Legend

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