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 1540 by gezelter, Mon Jan 17 21:34:36 2011 UTC

# Line 50 | Line 50 | namespace OpenMD {
50      int nAtoms;
51      int nGroups;
52  
53 <    AtomCommRealI = new Comm<I,RealType>(nAtoms);
54 <    AtomCommVectorI = new Comm<I,Vector3d>(nAtoms);
55 <    AtomCommMatrixI = new Comm<I,Mat3x3d>(nAtoms);
53 >    AtomCommRealI = new Communicator<Row,RealType>(nAtoms);
54 >    AtomCommVectorI = new Communicator<Row,Vector3d>(nAtoms);
55 >    AtomCommMatrixI = new Communicator<Row,Mat3x3d>(nAtoms);
56  
57 <    AtomCommRealJ = new Comm<J,RealType>(nAtoms);
58 <    AtomCommVectorJ = new Comm<J,Vector3d>(nAtoms);
59 <    AtomCommMatrixJ = new Comm<J,Mat3x3d>(nAtoms);
57 >    AtomCommRealJ = new Communicator<Column,RealType>(nAtoms);
58 >    AtomCommVectorJ = new Communicator<Column,Vector3d>(nAtoms);
59 >    AtomCommMatrixJ = new Communicator<Column,Mat3x3d>(nAtoms);
60  
61 <    cgCommVectorI = new Comm<I,Vector3d>(nGroups);
62 <    cgCommVectorJ = new Comm<J,Vector3d>(nGroups);
61 >    cgCommVectorI = new Communicator<Row,Vector3d>(nGroups);
62 >    cgCommVectorJ = new Communicator<Column,Vector3d>(nGroups);
63      // more to come
64   #endif
65    }
# Line 69 | Line 69 | namespace OpenMD {
69    void ForceDecomposition::distributeData()  {
70   #ifdef IS_MPI
71      Snapshot* snap = sman_->getCurrentSnapshot();
72 <
72 >    
73      // gather up the atomic positions
74      AtomCommVectorI->gather(snap->atomData.position,
75                              snap->atomIData.position);
76      AtomCommVectorJ->gather(snap->atomData.position,
77 <                           snap->atomJData.position);
77 >                            snap->atomJData.position);
78      
79      // gather up the cutoff group positions
80      cgCommVectorI->gather(snap->cgData.position,
81 <                         snap->cgIData.position);
81 >                          snap->cgIData.position);
82      cgCommVectorJ->gather(snap->cgData.position,
83 <                         snap->cgJData.position);
83 >                          snap->cgJData.position);
84      
85      // if needed, gather the atomic rotation matrices
86      if (snap->atomData.getStorageLayout() & DataStorage::dslAmat) {
87        AtomCommMatrixI->gather(snap->atomData.aMat,
88 <                             snap->atomIData.aMat);
88 >                              snap->atomIData.aMat);
89        AtomCommMatrixJ->gather(snap->atomData.aMat,
90 <                             snap->atomJData.aMat);
90 >                              snap->atomJData.aMat);
91      }
92      
93      // if needed, gather the atomic eletrostatic frames
94      if (snap->atomData.getStorageLayout() & DataStorage::dslElectroFrame) {
95        AtomCommMatrixI->gather(snap->atomData.electroFrame,
96 <                             snap->atomIData.electroFrame);
96 >                              snap->atomIData.electroFrame);
97        AtomCommMatrixJ->gather(snap->atomData.electroFrame,
98 <                             snap->atomJData.electroFrame);
98 >                              snap->atomJData.electroFrame);
99      }
100   #endif      
101    }
# Line 103 | Line 103 | namespace OpenMD {
103    void ForceDecomposition::collectIntermediateData() {
104   #ifdef IS_MPI
105      Snapshot* snap = sman_->getCurrentSnapshot();
106 –    // gather up the atomic positions
106      
107      if (snap->atomData.getStorageLayout() & DataStorage::dslDensity) {
108        AtomCommRealI->scatter(snap->atomIData.density,
109 <                            snap->atomData.density);
109 >                             snap->atomData.density);
110        std::vector<RealType> rho_tmp;
111        int n = snap->getNumberOfAtoms();
112        rho_tmp.reserve( n );
# Line 123 | Line 122 | namespace OpenMD {
122      Snapshot* snap = sman_->getCurrentSnapshot();
123      if (snap->atomData.getStorageLayout() & DataStorage::dslFunctional) {
124        AtomCommRealI->gather(snap->atomData.functional,
125 <                           snap->atomIData.functional);
125 >                            snap->atomIData.functional);
126        AtomCommRealJ->gather(snap->atomData.functional,
127 <                           snap->atomJData.functional);
127 >                            snap->atomJData.functional);
128      }
129      
130      if (snap->atomData.getStorageLayout() & DataStorage::dslFunctionalDerivative) {
131        AtomCommRealI->gather(snap->atomData.functionalDerivative,
132 <                           snap->atomIData.functionalDerivative);
132 >                            snap->atomIData.functionalDerivative);
133        AtomCommRealJ->gather(snap->atomData.functionalDerivative,
134 <                           snap->atomJData.functionalDerivative);
134 >                            snap->atomJData.functionalDerivative);
135      }
136   #endif
137    }
# Line 140 | Line 139 | namespace OpenMD {
139    
140    void ForceDecomposition::collectData() {
141   #ifdef IS_MPI
142 +    Snapshot* snap = sman_->getCurrentSnapshot();
143 +    int n = snap->getNumberOfAtoms();
144 +
145 +    std::vector<Vector3d> frc_tmp;
146 +    frc_tmp.reserve( n );
147 +    
148 +    AtomCommVectorI->scatter(snap->atomIData.force, frc_tmp);
149 +    for (int i = 0; i < n; i++)
150 +      snap->atomData.force[i] += frc_tmp[i];
151 +    
152 +    AtomCommVectorJ->scatter(snap->atomJData.force, frc_tmp);
153 +    for (int i = 0; i < n; i++)
154 +      snap->atomData.force[i] += frc_tmp[i];
155 +    
156 +    
157 +    if (snap->atomData.getStorageLayout() & DataStorage::dslTorque) {
158 +      std::vector<Vector3d> trq_tmp;
159 +      trq_tmp.reserve( n );
160 +      
161 +      AtomCommVectorI->scatter(snap->atomIData.torque, trq_tmp);
162 +      for (int i = 0; i < n; i++)
163 +        snap->atomData.torque[i] += trq_tmp[i];
164 +      
165 +      AtomCommVectorJ->scatter(snap->atomJData.torque, trq_tmp);
166 +      for (int i = 0; i < n; i++)
167 +        snap->atomData.torque[i] += trq_tmp[i];
168 +    }
169 +    
170 +    // Still need pot!
171 +    
172 +
173 +
174   #endif
175    }
176    

Diff Legend

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