# | 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 | ||
43 | #ifndef PARALLEL_FORCEMATRIXDECOMPOSITION_HPP | |
# | Line 55 | Line 56 | namespace OpenMD { | |
56 | ||
57 | class ForceMatrixDecomposition : public ForceDecomposition { | |
58 | public: | |
59 | < | ForceMatrixDecomposition(SimInfo* info) : ForceDecomposition(info) {sman_ = info_->getSnapshotManager();} |
59 | > | ForceMatrixDecomposition(SimInfo* info, InteractionManager* iMan); |
60 | > | |
61 | void distributeInitialData(); | |
62 | + | void zeroWorkArrays(); |
63 | void distributeData(); | |
64 | void collectIntermediateData(); | |
65 | void distributeIntermediateData(); | |
66 | + | void collectSelfData(); |
67 | void collectData(); | |
68 | ||
69 | // neighbor list routines | |
66 | – | bool checkNeighborList(); |
70 | vector<pair<int, int> > buildNeighborList(); | |
71 | ||
72 | // group bookkeeping | |
73 | < | pair<int, int> getGroupTypes(int cg1, int cg2); |
73 | > | groupCutoffs getGroupCutoffs(int cg1, int cg2); |
74 | > | Vector3d getGroupVelocityColumn(int cg2); |
75 | ||
76 | // Group->atom bookkeeping | |
77 | vector<int> getAtomsInGroupRow(int cg1); | |
78 | vector<int> getAtomsInGroupColumn(int cg2); | |
79 | Vector3d getAtomToGroupVectorRow(int atom1, int cg1); | |
80 | Vector3d getAtomToGroupVectorColumn(int atom2, int cg2); | |
81 | < | RealType getMfactRow(int atom1); |
82 | < | RealType getMfactColumn(int atom2); |
81 | > | RealType getMassFactorRow(int atom1); |
82 | > | RealType getMassFactorColumn(int atom2); |
83 | ||
84 | // spatial data | |
85 | Vector3d getIntergroupVector(int cg1, int cg2); | |
86 | Vector3d getInteratomicVector(int atom1, int atom2); | |
87 | ||
88 | // atom bookkeeping | |
89 | < | vector<int> getAtomList(); |
90 | < | vector<int> getSkipsForAtom(int atom1); |
91 | < | bool skipAtomPair(int atom1, int atom2); |
89 | > | int getNAtomsInRow(); |
90 | > | int getTopologicalDistance(int atom1, int atom2); |
91 | > | vector<int> getExcludesForAtom(int atom1); |
92 | > | bool skipAtomPair(int atom1, int atom2, int cg1, int cg2); |
93 | > | bool excludeAtomPair(int atom1, int atom2); |
94 | void addForceToAtomRow(int atom1, Vector3d fg); | |
95 | void addForceToAtomColumn(int atom2, Vector3d fg); | |
96 | + | Vector3d getAtomVelocityColumn(int atom2); |
97 | ||
98 | // filling interaction blocks with pointers | |
99 | < | InteractionData fillInteractionData(int atom1, int atom2); |
100 | < | InteractionData fillSkipData(int atom1, int atom2); |
94 | < | SelfData fillSelfData(int atom1); |
99 | > | void fillInteractionData(InteractionData &idat, int atom1, int atom2); |
100 | > | void unpackInteractionData(InteractionData &idat, int atom1, int atom2); |
101 | ||
102 | private: | |
103 | < | SnapshotManager* sman_; |
98 | < | Snapshot* snap_; |
99 | < | int storageLayout_; |
100 | < | vector<Vector3i> Cells; |
103 | > | void createGtypeCutoffMap(); |
104 | ||
105 | int nLocal_; | |
106 | int nGroups_; | |
107 | + | vector<int> AtomLocalToGlobal; |
108 | + | vector<int> cgLocalToGlobal; |
109 | + | vector<RealType> groupCutoff; |
110 | + | vector<int> groupToGtype; |
111 | ||
112 | #ifdef IS_MPI | |
113 | < | DataStorage atomRowData; |
107 | < | DataStorage atomColData; |
113 | > | DataStorage atomRowData; DataStorage atomColData; |
114 | DataStorage cgRowData; | |
115 | DataStorage cgColData; | |
116 | ||
# | Line 113 | Line 119 | namespace OpenMD { | |
119 | int nGroupsInRow_; | |
120 | int nGroupsInCol_; | |
121 | ||
122 | < | Communicator<Row, int>* AtomCommIntRow; |
123 | < | Communicator<Row, RealType>* AtomCommRealRow; |
118 | < | Communicator<Row, Vector3d>* AtomCommVectorRow; |
119 | < | Communicator<Row, Mat3x3d>* AtomCommMatrixRow; |
122 | > | Communicator<Row> rowComm; |
123 | > | Communicator<Column> colComm; |
124 | ||
125 | < | Communicator<Column, int>* AtomCommIntColumn; |
126 | < | Communicator<Column, RealType>* AtomCommRealColumn; |
127 | < | Communicator<Column, Vector3d>* AtomCommVectorColumn; |
128 | < | Communicator<Column, Mat3x3d>* AtomCommMatrixColumn; |
125 | > | Plan<int>* AtomPlanIntRow; |
126 | > | Plan<RealType>* AtomPlanRealRow; |
127 | > | Plan<Vector3d>* AtomPlanVectorRow; |
128 | > | Plan<Mat3x3d>* AtomPlanMatrixRow; |
129 | > | Plan<potVec>* AtomPlanPotRow; |
130 | ||
131 | < | Communicator<Row, int>* cgCommIntRow; |
132 | < | Communicator<Row, Vector3d>* cgCommVectorRow; |
133 | < | Communicator<Column, int>* cgCommIntColumn; |
134 | < | Communicator<Column, Vector3d>* cgCommVectorColumn; |
131 | > | Plan<int>* AtomPlanIntColumn; |
132 | > | Plan<RealType>* AtomPlanRealColumn; |
133 | > | Plan<Vector3d>* AtomPlanVectorColumn; |
134 | > | Plan<Mat3x3d>* AtomPlanMatrixColumn; |
135 | > | Plan<potVec>* AtomPlanPotColumn; |
136 | ||
137 | < | vector<vector<RealType> > pot_row; |
138 | < | vector<vector<RealType> > pot_col; |
137 | > | Plan<int>* cgPlanIntRow; |
138 | > | Plan<Vector3d>* cgPlanVectorRow; |
139 | > | Plan<int>* cgPlanIntColumn; |
140 | > | Plan<Vector3d>* cgPlanVectorColumn; |
141 | > | |
142 | > | // work arrays for assembling potential energy |
143 | > | vector<potVec> pot_row; |
144 | > | vector<potVec> pot_col; |
145 | > | |
146 | > | vector<potVec> expot_row; |
147 | > | vector<potVec> expot_col; |
148 | > | |
149 | vector<int> identsRow; | |
150 | vector<int> identsCol; | |
151 | ||
152 | < | vector<int> AtomLocalToGlobal; |
152 | > | vector<AtomType*> atypesRow; |
153 | > | vector<AtomType*> atypesCol; |
154 | > | |
155 | vector<int> AtomRowToGlobal; | |
156 | vector<int> AtomColToGlobal; | |
157 | < | vector<int> cgLocalToGlobal; |
157 | > | |
158 | > | public: |
159 | vector<int> cgRowToGlobal; | |
160 | vector<int> cgColToGlobal; | |
161 | ||
162 | < | vector<vector<int> > CellListRow; |
163 | < | vector<vector<int> > CellListCol; |
164 | < | #else |
165 | < | vector<vector<int> > CellList; |
162 | > | private: |
163 | > | vector<RealType> groupCutoffRow; |
164 | > | vector<RealType> groupCutoffCol; |
165 | > | vector<int> groupColToGtype; |
166 | > | vector<int> groupRowToGtype; |
167 | > | |
168 | > | vector<vector<int> > cellListRow_; |
169 | > | vector<vector<int> > cellListCol_; |
170 | > | |
171 | > | vector<vector<int> > groupListRow_; |
172 | > | vector<vector<int> > groupListCol_; |
173 | > | |
174 | > | vector<RealType> massFactorsRow; |
175 | > | vector<RealType> massFactorsCol; |
176 | #endif | |
148 | – | vector<RealType> pot_local; |
177 | ||
178 | }; | |
179 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |