-
Notifications
You must be signed in to change notification settings - Fork 0
/
AV.h
276 lines (234 loc) · 8.9 KB
/
AV.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
#include <iostream>
#include <unistd.h>
#include <memory>
#include <stdlib.h>
#include <cmath>
#include <queue>
#include <set>
#include <vector>
using std::cout;
using std::endl;
//using namespace std::chrono;
#ifndef AV_H
#define AV_H
namespace AnisoVoro {
class Queue {
public:
Queue();
Queue(int initialSize);
int front();
//bool full();
bool empty();
bool pop();
bool push(int val);
int at(int i);
int size();
void display();
void emptyQueue();
private:
int sz;
int head;
int tail;
int capacity;
bool full;
std::unique_ptr<int[]> queueArray;
};
class DomainDecomposition{
public:
int rank {0};
int P {1};
int mainDomainNumber {0};
int localNumber {0};
int length {1};
int mainCount {1};
int numberInLocal {1};
int localXMin, localXMax {1};
int localYMin, localYMax {1};
int localZMin, localZMax {1};
//Neighbors for 2D
//Need to figure out 3D, pretty simple though
int mainPlusX, mainMinusX {-1};
int mainPlusY, mainMinusY {-1};
int mainPlusYPlusX, mainPlusYMinusX {-1};
int mainMinusYPlusX, mainMinusYMinusX {-1};
//Additional Neighbors for 3D
int mainPlusZ, mainMinusZ {-1};
int mainPlusZPlusX, mainPlusZMinusX {-1};
int mainPlusZPlusY, mainPlusZMinusY {-1};
int mainPlusZPlusYPlusX, mainPlusZPlusYMinusX {-1};
int mainPlusZMinusYPlusX, mainPlusZMinusYMinusX {-1};
int mainMinusZPlusX, mainMinusZMinusX {-1};
int mainMinusZPlusY, mainMinusZMinusY {-1};
int mainMinusZPlusYPlusX, mainMinusZPlusYMinusX {-1};
int mainMinusZMinusYPlusX, mainMinusZMinusYMinusX {-1};
DomainDecomposition();
DomainDecomposition(int rank, int P);
void divideSimBox2D(int xLength, int yLength);
/*
void divideSimBox3D(int xLength, int yLength, int zLength);
int PlusX();
int PlusY();
int PlusZ();
int MinusX();
int MinusY();
int MinusZ();
void sendData(&int data, int recvRank);
void ReceiveData(&int data, int sendRank);
*/
private:
void mainNeighbors2D();
};
class Position {
public:
double x, y, z;
Position();
Position(double x, double y, double z);
//friend std::ostream& operator<<(std::ostream &os, const Position &p);
//Position& operator<<(const Position& p);
//~Position();
};
//Shapes are centered at the origin by default
class Shape {
public:
std::vector<Position> points;
int insphereRadius;
//int voxDegree;
Shape();
Shape(std::vector<Position>& points);
Shape(std::vector<int> &shapePoints, int xDim, int yDim, int zDim, int voxDegree);
//shapeFromVertices(std::vector<Position>& v, int vD);
};
class Quaternion {
public:
double w;
double x;
double y;
double z;
Quaternion();
Quaternion(double w, double x, double y, double z);
};
Position rotatePoint(Position p, Quaternion q);
Position rotatePoint(double pd[3], double qd[4]);
class BoxDim {
public:
double x, y, z;
BoxDim();
BoxDim(double x, double y, double z);
void print();
};
class VoxelIndex{
public:
int i, x, y, z;
VoxelIndex();
VoxelIndex(Position vbp, BoxDim vbd);
VoxelIndex(Position vbp, BoxDim vbd, Position refCorner);
VoxelIndex(int i, BoxDim vbd);
VoxelIndex(int i, BoxDim vbd, Position refCorner);
//~VoxelIndex();
};
class VoxelBit {
public:
int layer {-1};
int fullNeighbors {0};
VoxelIndex index;
std::set<int> origins;
bool isParticle {false};
bool isBoundary {false};
bool isGhost {false};
//~VoxelBit();
VoxelBit();
VoxelBit(int i, bool isParticle, int particleNum, BoxDim vbd);
VoxelBit(int i, bool isParticle, int particleNum, BoxDim vbd, Position refCorner);
void getNeighborsIndices2D(BoxDim vbd, int (&neighbors)[8]);
void getNeighborsIndices3D(BoxDim vbd, int (&neighbors)[26]);
};
class VoxelVector {
public:
std::vector<VoxelBit> v;
VoxelVector();
VoxelVector(int size);
VoxelVector(int xLength, int yLength, int zLength, int voxDegree);
};
class SimBox {
public:
std::vector<VoxelBit> pVoxArr; // initial particle voxelization
std::vector<Shape> shapeArr;
std::vector<Position> positions;
int voxDegree; //number of voxels per simulation box unit
BoxDim totalBoxDim;
BoxDim voxBoxDim; //simUnitBoxDim * voxDegree
bool is2D;
int partNum;
Position mainRefCorner;
Position voxRefCorner;
int mode;
SimBox();
//SimBox(double xLength, double yLength, double zLength,
// std::vector<VoxelBit>& pVoxArr, int voxDegree);
//SimBox(double xLength, double yLength, double zLength, int voxDegree);
//SimBox(double xLength, double yLength, double zLength, int voxDegree, int mode);
SimBox(double xLength, double yLength, double zLength, int voxDegree, int mode, int rank, int mpiWorldSize);
void setReferenceCorner(Position p);
void setVoxel(Position p, bool isParticle, int particleNum);
void placeShape(Shape s, Quaternion q, Position p, int particleNum);
//void particleTypes(std::vector<int>& type_id,
// std::vector<std::vector<Position>>& particleTypes,
// std::vector<Position> positions,
// std::vector<Quaternion>& orientations);
//std::vector<double> localDensity();
//std::vector<std::vector<int> > densityNeighbors();
int particleNum();
void particleNum(int num);
void printBox();
void printBoundaries();
void printCells();
void printVoxRank();
void runVoro();
//~SimBox();
private:
DomainDecomposition dcomp;
int rank; //MPI Rank
int mpiWorldSize;//MPI world size
std::vector<int> mpiNeighbors;
std::vector<int> voxelTracker;
std::vector<VoxelBit> neighbors;
std::queue<int> layerRun;
std::queue<int> originRun;
std::queue<int> ghostRun;
std::queue<int> boundaryIndices;
//There's -1's between each particle
//neither, particle, boundary == 0, 1, 2
std::vector<int> ghostsToSend[6];
std::vector<int> ghostsToRecv[6];
//Stop asking for communication when these are the length of the sides
int ghostsReceived[6] {0};
int ghostsSent[6] {0};
int unseenVoxs;
void setDevice(int mode);
void setDevice(int mode, int rank, int mpiWorldSize);
void adjustForGhostCells(double *xLength, double *yLength, double *zLength);
void adjustGhostCells();
void updateGhosts(int layer);
void sendGhosts2D(int layer, int direction, int receiver, int begin, int end, int skip);
void recvGhosts2D(int layer, int direction, int sender);
void integrateGhosts(std::vector<int>& ghosts, int direction, int layer);
void beginEndSkipForGhosts(int direction, int *begin, int *end, int *skip);
bool allHaunted();
void adjustVoxRefCorner();
bool insideVoxBox(Position p);
void initialize();
void adjustInputPosition(Position &p);
void adjustOutputPosition(Position &p);
int indexFromPosition(Position p);
Position positionFromIndex(int i);
void initializeQueue();
void runLayerByLayer();
void initializeQueueMPI();
void runLayerByLayerMPI();
void runLayerByLayerGPU();
void updateNeighbors(int currentLayer, VoxelBit& v);
void updateOrigins(int currentLayer);
void originUpdater(int currentLayer, VoxelBit& v);
};
}
#endif