diff --git a/src/GridGenerator/geometries/BoundingBox/BoundingBox.cu b/src/GridGenerator/geometries/BoundingBox/BoundingBox.cu
index 38a8174efadc5045452fe7a550defad9b016ddf6..7c92d04c458e601324292d881b410a38bb5a00e8 100644
--- a/src/GridGenerator/geometries/BoundingBox/BoundingBox.cu
+++ b/src/GridGenerator/geometries/BoundingBox/BoundingBox.cu
@@ -55,7 +55,22 @@ template <typename T>
}
- template <typename T>
+ HOSTDEVICE BoundingBox<real> BoundingBox<real>::makeRealNodeBox(const Triangle& t, const real& delta)
+{
+ BoundingBox<real> box;
+
+ real minX, maxX, minY, maxY, minZ, maxZ;
+ t.setMinMax(minX, maxX, minY, maxY, minZ, maxZ);
+
+ calculateMinMaxOnNodes(box.minX, box.maxX, minX, maxX, delta);
+ calculateMinMaxOnNodes(box.minY, box.maxY, minY, maxY, delta);
+ calculateMinMaxOnNodes(box.minZ, box.maxZ, minZ, maxZ, delta);
+
+ return box;
+}
+
+
+template <typename T>
HOST BoundingBox<T> BoundingBox<T>::makeInvalidMinMaxBox()
{
BoundingBox<T> box = BoundingBox<T>(std::numeric_limits<T>::max(),
@@ -80,6 +95,19 @@ template <typename T>
return box;
}
+ template <>
+ HOSTDEVICE void BoundingBox<real>::calculateMinMaxOnNodes(real &minNode, real &maxNode, const real &minExact, const real &maxExact, const real& delta)
+ {
+ minNode = ceil(minExact - 1.0);
+ maxNode = floor(maxExact + 1.0);
+ if (minNode + 0.5 < minExact)
+ minNode += 0.5;
+
+
+ if (maxNode - 0.5 > maxExact)
+ maxNode -= 0.5;
+ }
+
template <>
HOSTDEVICE void BoundingBox<int>::calculateMinMaxOnNodes(int &minNode, int &maxNode, const real &minExact, const real &maxExact)
{
diff --git a/src/GridGenerator/geometries/BoundingBox/BoundingBox.cuh b/src/GridGenerator/geometries/BoundingBox/BoundingBox.cuh
index 837851131eb861dc4d91b16f22ba227003c0ce87..72499a4348a0852c795138605daf0c9c47bf0749 100644
--- a/src/GridGenerator/geometries/BoundingBox/BoundingBox.cuh
+++ b/src/GridGenerator/geometries/BoundingBox/BoundingBox.cuh
@@ -29,7 +29,8 @@ public:
BoundingBox(const BoundingBox<real> &t);
public:
- HOST static BoundingBox<real> makeExactBox(const Triangle &t);
+ HOST static BoundingBox<real> makeExactBox(const Triangle &t);
+ HOSTDEVICE static BoundingBox<real> makeRealNodeBox(const Triangle &t, const real& delta);
HOSTDEVICE static BoundingBox<int> makeNodeBox(const Triangle &t);
HOST static BoundingBox<T> makeInvalidMinMaxBox();
@@ -51,6 +52,7 @@ public:
private:
HOSTDEVICE static void calculateMinMaxOnNodes(int &minNode, int &maxNode, const real &minExact, const real &maxExact);
+ HOSTDEVICE static void calculateMinMaxOnNodes(real &minNode, real &maxNode, const real &minExact, const real &maxExact, const real& delta);
bool isInside(const Vertex &v) const;
void getPoints(Vertex v[8]) const;
diff --git a/src/GridGenerator/geometries/BoundingBox/BoundingBoxTest.cpp b/src/GridGenerator/geometries/BoundingBox/BoundingBoxTest.cpp
index 1a39a2f38c53469d0c93bb9ad77c039c3e28dee3..31212856eec3b89e4de8090aa274f491e5e56a8f 100644
--- a/src/GridGenerator/geometries/BoundingBox/BoundingBoxTest.cpp
+++ b/src/GridGenerator/geometries/BoundingBox/BoundingBoxTest.cpp
@@ -134,3 +134,19 @@ TEST(BoundingBoxTest, isInside_false)
EXPECT_FALSE(box.isInside(t));
}
+TEST(BoundingBoxTest, createNodeBoxWithFloastingPointValues)
+{
+ Triangle t = Triangle(Vertex(1.34, -2.01, 1.8), Vertex(2, 2, 1.9), Vertex(3.99, 2.1, 1.51), Vertex(0.0, 0.0, 0.0));
+ real delta = 0.5;
+
+ BoundingBox<real> box = BoundingBox<real>::makeRealNodeBox(t, delta);
+
+ EXPECT_THAT(box.minX, DoubleEq(1.0));
+ EXPECT_THAT(box.minY, DoubleEq(-2.5));
+ EXPECT_THAT(box.minZ, DoubleEq(1.5));
+
+ EXPECT_THAT(box.maxX, DoubleEq(4));
+ EXPECT_THAT(box.maxY, DoubleEq(2.5));
+ EXPECT_THAT(box.maxZ, DoubleEq(2.0));
+}
+
diff --git a/src/GridGenerator/geometries/Geometry/Geometry.cu b/src/GridGenerator/geometries/Geometry/Geometry.cu
index 9b570905639b29aa43d4499cfa88261e08a111fa..ccce72d8b65924e2640f4461e6e7962749751f17 100644
--- a/src/GridGenerator/geometries/Geometry/Geometry.cu
+++ b/src/GridGenerator/geometries/Geometry/Geometry.cu
@@ -19,6 +19,15 @@ Geometry::Geometry(const std::string& input, const BoundingBox<int>& box, const
this->findNeighbors();
}
+Geometry::Geometry(const std::string& inputPath)
+{
+ this->transformator = new TransformatorImp();
+
+ this->triangleVec = STLReader::readSTL(inputPath);
+ initalizeDataFromTriangles();
+ this->findNeighbors();
+}
+
Geometry::Geometry(const Geometry& geo)
{
this->transformator = new TransformatorImp();
diff --git a/src/GridGenerator/geometries/Geometry/Geometry.cuh b/src/GridGenerator/geometries/Geometry/Geometry.cuh
index 332916c97426bb194be9798eefe155f16bda8b78..123011dddee477c5b5b0d91fe3f1be164b9f6efa 100644
--- a/src/GridGenerator/geometries/Geometry/Geometry.cuh
+++ b/src/GridGenerator/geometries/Geometry/Geometry.cuh
@@ -22,6 +22,7 @@ struct Geometry
public:
VF_PUBLIC Geometry();
VF_PUBLIC Geometry(const Geometry& geo);
+ VF_PUBLIC Geometry(const std::string& inputPath);
VF_PUBLIC Geometry(const std::string& inputPath, const BoundingBox<int> &box, const Transformator *trafo);
VF_PUBLIC ~Geometry();
VF_PUBLIC Transformator* getTransformator();
diff --git a/src/GridGenerator/grid/Grid.cu b/src/GridGenerator/grid/Grid.cu
index ad0c7a69a3e0ae30638bc94b7900fbc7442ae1f4..41debd4dc8abcdcd21a2ef7fc85f31710ad5a94a 100644
--- a/src/GridGenerator/grid/Grid.cu
+++ b/src/GridGenerator/grid/Grid.cu
@@ -16,6 +16,30 @@
__constant__ int DIRECTIONS[DIR_END_MAX][DIMENSION];
+HOSTDEVICE Grid::Grid(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, Distribution &d) : sX(startX), sY(startY), sZ(startZ), eX(endX), eY(endY), eZ(endZ), delta(delta), d(d)
+{
+ real length = endX - startX;
+ real width = endY - startY;
+ real height = endZ - startZ;
+
+ nx = (int)((length + delta) / delta);
+ ny = (int)((width + delta) / delta);
+ nz = (int)((height + delta) / delta);
+
+ this->size = nx * ny * nz;
+ this->reducedSize = size;
+
+ const unsigned long distributionSize = size * (d.dir_end + 1);
+ this->d.f = new real[distributionSize](); // automatic initialized with zeros
+ this->field = new char[this->size];
+
+ this->neighborIndexX = new int[this->size];
+ this->neighborIndexY = new int[this->size];
+ this->neighborIndexZ = new int[this->size];
+
+ this->matrixIndex = new uint[this->size];
+}
+
HOSTDEVICE Grid::Grid(){};
HOSTDEVICE Grid::Grid(char *field, int startX, int startY, int startZ, int nx, int ny, int nz, Distribution &d)
: field(field), startX(startX), startY(startY), startZ(startZ), nx(nx), ny(ny), nz(nz), d(d)
@@ -64,31 +88,39 @@ HOSTDEVICE char Grid::getFieldEntry(const Vertex &v) const
return this->field[transCoordToIndex(v)];
}
-HOSTDEVICE int Grid::transCoordToIndex(const int &x, const int &y, const int &z) const
+HOSTDEVICE int Grid::transCoordToIndex(const real &x, const real &y, const real &z) const
{
- return transCoordToIndex(Vertex((real)x, (real)y, (real)z));
+ return transCoordToIndex(Vertex(x,y,z));
}
HOSTDEVICE int Grid::transCoordToIndex(const Vertex &v) const
{
-#ifdef DEBUG
- if (isOutOfRange(v))
- { printf("Function: transCoordToIndex. Coordinates are out of range and cannot calculate the index. Exit Program!\n");/* exit(1);*/ };
-#endif
- return (int)(v.x + nx * (v.y + ny * v.z));
+//#ifdef DEBUG
+// if (isOutOfRange(v))
+// { printf("Function: transCoordToIndex. Coordinates are out of range and cannot calculate the index. Exit Program!\n");/* exit(1);*/ };
+//#endif
+ int x = (int)((v.x - sX) / delta);
+ int y = (int)((v.y - sY) / delta);
+ int z = (int)((v.z - sZ) / delta);
+
+ return x + nx * (y + ny * z);
}
-HOSTDEVICE void Grid::transIndexToCoords(const int index, unsigned int &x, unsigned int &y, unsigned int &z) const
+HOSTDEVICE void Grid::transIndexToCoords(const int index, real &x, real &y, real &z) const
{
-#ifdef DEBUG
- if (index < 0 || index >= (int)size)
- {
- printf("Function: transIndexToCoords. Grid Index: %d, size: %d. Exit Program!\n", index, size); /*exit(1);*/
- };
-#endif
+//#ifdef DEBUG
+// if (index < 0 || index >= (int)size)
+// {
+// printf("Function: transIndexToCoords. Grid Index: %d, size: %d. Exit Program!\n", index, size); /*exit(1);*/
+// };
+//#endif
x = index % nx;
y = (index / nx) % ny;
z = ((index / nx) / ny) % nz;
+
+ x = (x + sX) * delta;
+ y = (y + sY) * delta;
+ z = (z + sZ) * delta;
}
char* Grid::toString(const char* name) const
@@ -122,6 +154,26 @@ HOSTDEVICE bool Grid::isOutOfRange(const Vertex &v) const
}
+HOSTDEVICE void Grid::meshTriangleExact(const Triangle &triangle)
+{
+ BoundingBox<real> box = BoundingBox<real>::makeRealNodeBox(triangle, delta);
+
+ for (real x = box.minX; x <= box.maxX; x += delta) {
+ for (real y = box.minY; y <= box.maxY; y += delta) {
+ for (real z = box.minZ; z <= box.maxZ; z += delta) {
+ Vertex point(x, y, z);
+ //if (isOutOfRange(point))
+ // continue;
+ const int value = triangle.isUnderFace(point);
+ setDebugPoint(point, value);
+
+ //if (value == Q)
+ // calculateQs(point, triangle);
+ }
+ }
+ }
+}
+
HOSTDEVICE void Grid::meshTriangle(const Triangle &triangle)
{
int x, y, z;
@@ -170,10 +222,10 @@ HOSTDEVICE void Grid::calculateQs(const Vertex &point, const Triangle &triangle)
HOSTDEVICE void Grid::setNeighborIndices(const int &index)
{
- unsigned int x, y, z;
+ real x, y, z;
this->transIndexToCoords(index, x, y, z);
- unsigned int neighborX, neighborY, neighborZ;
+ real neighborX, neighborY, neighborZ;
this->getNeighborCoords(neighborX, neighborY, neighborZ, x, y, z);
neighborIndexX[index] = (unsigned int) transCoordToIndex(neighborX, y, z);
@@ -207,18 +259,18 @@ HOSTDEVICE bool Grid::isNeighborInvalid(const int &index)
HOSTDEVICE void Grid::findNeighborIndex(int index)
{
- unsigned int x, y, z;
+ real x, y, z;
int nodeIndex = this->matrixIndex[index];
this->transIndexToCoords(this->matrixIndex[index], x, y, z);
- unsigned int neighborXCoord, neighborYCoord, neighborZCoord;
+ real neighborXCoord, neighborYCoord, neighborZCoord;
getNeighborCoords(neighborXCoord, neighborYCoord, neighborZCoord, x, y, z);
this->neighborIndexX[nodeIndex] = getNeighborIndex(index, this->neighborIndexX[nodeIndex], neighborXCoord, y, z);
this->neighborIndexY[nodeIndex] = getNeighborIndex(index, this->neighborIndexY[nodeIndex], x, neighborYCoord, z);
this->neighborIndexZ[nodeIndex] = getNeighborIndex(index, this->neighborIndexZ[nodeIndex], x, y, neighborZCoord);
}
-HOSTDEVICE int Grid::getNeighborIndex(const int &nodeIndex, int &neighborIndex, const int &expectedX, const int &expectedY, const int &expectedZ)
+HOSTDEVICE int Grid::getNeighborIndex(const int &nodeIndex, int &neighborIndex, const real &expectedX, const real &expectedY, const real &expectedZ)
{
while (neighborIndex >= (int)this->reducedSize)
{
@@ -226,7 +278,7 @@ HOSTDEVICE int Grid::getNeighborIndex(const int &nodeIndex, int &neighborIndex,
//printf("here\n");
}
if (neighborIndex >= 0) {
- unsigned int neighborX, neighborY, neighborZ;
+ real neighborX, neighborY, neighborZ;
this->transIndexToCoords(this->matrixIndex[neighborIndex], neighborX, neighborY, neighborZ);
while (!(neighborX == expectedX && neighborY == expectedY && neighborZ == expectedZ)) {
neighborIndex--;
@@ -270,11 +322,11 @@ HOST void Grid::removeInvalidNodes()
this->matrixIndex = indices_reduced;
}
-HOSTDEVICE void Grid::getNeighborCoords(unsigned int &neighborX, unsigned int &neighborY, unsigned int &neighborZ, const unsigned int x, const unsigned int y, const unsigned int z) const
+HOSTDEVICE void Grid::getNeighborCoords(real &neighborX, real &neighborY, real &neighborZ, const real x, const real y, const real z) const
{
- neighborX = x + 1 < nx ? x + 1 : 0;
- neighborY = y + 1 < ny ? y + 1 : 0;
- neighborZ = z + 1 < nz ? z + 1 : 0;
+ neighborX = x + delta < nx ? x + delta : startX;
+ neighborY = y + delta < ny ? y + delta : startY;
+ neighborZ = z + delta < nz ? z + delta : startZ;
}
@@ -285,13 +337,12 @@ HOSTDEVICE bool Grid::isStopper(int index) const
HOSTDEVICE bool Grid::previousCellHasFluid(int index) const
{
- unsigned int ux, uy, uz;
- this->transIndexToCoords(index, ux, uy, uz);
+ real x, y, z;
+ this->transIndexToCoords(index, x, y, z);
- int x(ux), y(uy), z(uz);
- int previousX = x - 1 >= 0 ? x - 1 : this->nx - 1;
- int previousY = y - 1 >= 0 ? y - 1 : this->ny - 1;
- int previousZ = z - 1 >= 0 ? z - 1 : this->nz - 1;
+ real previousX = x - delta >= 0 ? x - delta : this->eX;
+ real previousY = y - delta >= 0 ? y - delta : this->eY;
+ real previousZ = z - delta >= 0 ? z - delta : this->eZ;
int indexpreviousX = this->transCoordToIndex(previousX, y, z);
int indexpreviousY = this->transCoordToIndex(x, previousY, z);
diff --git a/src/GridGenerator/grid/Grid.cuh b/src/GridGenerator/grid/Grid.cuh
index 1a8a5eee1ffde0df6f2eb130f68bab5086a5908e..9e1d6cdc50175ed92d53baa92fffcb39c742b8fe 100644
--- a/src/GridGenerator/grid/Grid.cuh
+++ b/src/GridGenerator/grid/Grid.cuh
@@ -18,6 +18,10 @@ extern CONSTANT int DIRECTIONS[DIR_END_MAX][DIMENSION];
struct VF_PUBLIC Grid
{
+ real sX = 0.0, sY = 0.0, sZ = 0.0;
+ real eX, eY, eZ;
+ real delta = 1.0;
+
char *field;
int startX, startY, startZ;
unsigned int nx, ny, nz;
@@ -28,6 +32,7 @@ struct VF_PUBLIC Grid
unsigned int *matrixIndex;
int reducedSize;
+ HOSTDEVICE Grid(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, Distribution &d);
HOSTDEVICE Grid();
HOSTDEVICE Grid(char *field, int startX, int startY, int startZ, int nx, int ny, int nz, Distribution &d);
@@ -39,15 +44,16 @@ struct VF_PUBLIC Grid
HOSTDEVICE void setFieldEntryToSolid(unsigned int index);
HOSTDEVICE void setFieldEntry(const Vertex &v, char val);
HOSTDEVICE char getFieldEntry(const Vertex &v) const;
- HOSTDEVICE int transCoordToIndex(const int &x, const int &y, const int &z) const;
+ HOSTDEVICE int transCoordToIndex(const real &x, const real &y, const real &z) const;
HOSTDEVICE int transCoordToIndex(const Vertex &v) const;
- HOSTDEVICE void transIndexToCoords(const int index, unsigned int &x, unsigned int &y, unsigned int &z) const;
+ HOSTDEVICE void transIndexToCoords(const int index, real &x, real &y, real &z) const;
HOSTDEVICE void print() const;
HOSTDEVICE void setDebugPoint(const Vertex &actualPoint, const int pointValue);
HOSTDEVICE bool isOutOfRange(const Vertex &actualPoint) const;
/*---------------------------------------------------------------------------------*/
HOSTDEVICE void meshTriangle(const Triangle &actualTriangle);
+ HOSTDEVICE void meshTriangleExact(const Triangle &triangle);
HOSTDEVICE void calculateQs(const Vertex &point, const Triangle &actualTriangle);
@@ -55,9 +61,9 @@ struct VF_PUBLIC Grid
/*---------------------------------------------------------------------------------*/
HOSTDEVICE void setNeighborIndices(const int &index);
- HOSTDEVICE void getNeighborCoords(unsigned int &neighborX, unsigned int &neighborY, unsigned int &neighborZ, const unsigned int x, const unsigned int y, const unsigned int z) const;
+ HOSTDEVICE void getNeighborCoords(real &neighborX, real &neighborY, real &neighborZ, const real x, const real y, const real z) const;
HOSTDEVICE void findNeighborIndex(int index);
- HOSTDEVICE int getNeighborIndex(const int &nodeIndex, int &nIndex, const int &x, const int &y, const int &z);
+ HOSTDEVICE int getNeighborIndex(const int &nodeIndex, int &neighborIndex, const real &expectedX, const real &expectedY, const real &expectedZ);
HOSTDEVICE void setInvalidNode(const int &index, bool &invalidNodeFound);
HOSTDEVICE bool isNeighborInvalid(const int &index);
diff --git a/src/GridGenerator/grid/GridBuilder/GridBuilder.h b/src/GridGenerator/grid/GridBuilder/GridBuilder.h
index f5491f9acff66c674407f66e3371016e9647fbdc..1ad018fe06a5753774a030227ef3ec362028f017 100644
--- a/src/GridGenerator/grid/GridBuilder/GridBuilder.h
+++ b/src/GridGenerator/grid/GridBuilder/GridBuilder.h
@@ -39,7 +39,6 @@ public:
virtual VF_PUBLIC ~GridBuilder() {};
- virtual void addGrid(real length, real width, real high, real delta, std::string distribution, std::shared_ptr<Transformator> trans) = 0;
virtual void meshGeometry(std::string input, int level) = 0;
virtual void deleteSolidNodes() = 0;
diff --git a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
index f0e0459bcbfab64bbc81ea15c443cf6d9e7e49d6..fd940a50890f1abdc0c895df7663fb1d44e1d2e8 100644
--- a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
+++ b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
@@ -55,15 +55,24 @@ void LevelGridBuilder::addGrid(uint minX, uint minY, uint minZ, uint maxX, uint
{
uint level = gridWrapper.size();
+ Grid grid(3, 3, 3, 12, 12, 12, 0.5, Distribution());
+
+ for (unsigned int index = 0; index < grid.size; index++)
+ {
+ grid.setNeighborIndices(index);
+ grid.matrixIndex[index] = index;
+ grid.setFieldEntryToFluid(index);
+ }
+
switch (this->device)
{
case GenerationDevice::CPU:
- this->gridWrapper.push_back(std::shared_ptr<GridWrapperCPU>(new GridWrapperCPU( , distribution)));
+ this->gridWrapper.push_back(std::shared_ptr<GridWrapperCPU>(new GridWrapperCPU(minX, minY, minZ, maxX, maxY, maxZ, distribution)));
break;
case GenerationDevice::GPU:
- this->gridWrapper.push_back(std::shared_ptr<GridWrapperGPU>(new GridWrapperGPU( , distribution)));
+ this->gridWrapper.push_back(std::shared_ptr<GridWrapperGPU>(new GridWrapperGPU(minX, minY, minZ, maxX, maxY, maxZ, distribution)));
break;
}
}
@@ -74,14 +83,12 @@ void LevelGridBuilder::meshGeometry(std::string input, int level)
{
checkLevel(level);
- Geometry* geometry = new Geometry(input, transformators[level].get());
+ //Geometry* geometry = new Geometry(input, transformators[level].get());
- if (geometry->size > 0)
- this->gridWrapper[level]->meshGrid(*geometry);
- //this->gridKernels[level][index]->copyDataFromGPU();
- delete geometry;
- }
- }
+ //if (geometry->size > 0)
+ // this->gridWrapper[level]->meshGrid(*geometry);
+ ////this->gridKernels[level][index]->copyDataFromGPU();
+ //delete geometry;
}
void LevelGridBuilder::deleteSolidNodes()
@@ -125,7 +132,7 @@ std::vector<std::string> LevelGridBuilder::getTypeOfBoundaryConditions() const
void LevelGridBuilder::writeGridToVTK(std::string output, int level)
{
checkLevel(level);
- GridVTKWriter::writeGridToVTK(this->gridWrapper[level]->grid, output, this->transformators[level], true);
+ GridVTKWriter::writeGridToVTK(this->gridWrapper[level]->grid, output);
}
@@ -142,25 +149,12 @@ void LevelGridBuilder::writeSimulationFiles(std::string output, BoundingBox<int>
std::shared_ptr<GridWrapper> LevelGridBuilder::getGridWrapper(int level, int box)
{
- return this->gridWrapper[level][box];
+ return this->gridWrapper[level];
}
void LevelGridBuilder::checkLevel(int level)
{
- if (level >= boxes.size()) { std::cout << "wrong level input... return to caller\n"; return; }
-}
-
-
-
-void LevelGridBuilder::setNumberOfNodes(real length, real width, real high, real delta)
-{
- int nx = (int)(length / delta);
- int ny = (int)(width / delta);
- int nz = (int)(high / delta);
-
- std::vector<int> dim = { nx,ny,nz };
- this->gridDimensions.push_back(dim);
-
+ if (level >= gridWrapper.size()) { std::cout << "wrong level input... return to caller\n"; return; }
}
@@ -185,12 +179,12 @@ void LevelGridBuilder::getNodeValues(real *xCoords, real *yCoords, real *zCoords
for (int i = 0; i < grid.reducedSize; i++)
{
- unsigned int x, y, z;
+ real x, y, z;
grid.transIndexToCoords(grid.matrixIndex[i], x, y, z);
- xCoords[i + 1] = (real)x;
- yCoords[i + 1] = (real)y;
- zCoords[i + 1] = (real)z;
+ xCoords[i + 1] = x;
+ yCoords[i + 1] = y;
+ zCoords[i + 1] = z;
neighborX[i + 1] = (unsigned int)(grid.neighborIndexX[grid.matrixIndex[i]] + 1);
neighborY[i + 1] = (unsigned int)(grid.neighborIndexY[grid.matrixIndex[i]] + 1);
neighborZ[i + 1] = (unsigned int)(grid.neighborIndexZ[grid.matrixIndex[i]] + 1);
@@ -243,7 +237,7 @@ void LevelGridBuilder::createBCVectors()
Grid grid = this->gridWrapper[0]->grid;
for (int i = 0; i < grid.reducedSize; i++)
{
- unsigned int x, y, z;
+ real x, y, z;
grid.transIndexToCoords(grid.matrixIndex[i], x, y, z);
if (grid.field[grid.matrixIndex[i]] == Q) /*addShortQsToVector(i);*/ addQsToVector(i);
@@ -355,9 +349,9 @@ void LevelGridBuilder::writeArrow(const int i, const int qi, const Vertex& start
Vertex LevelGridBuilder::getVertex(int matrixIndex) const
{
- unsigned int x, y, z;
+ real x, y, z;
this->gridWrapper[0]->grid.transIndexToCoords(matrixIndex, x, y, z);
- return Vertex((real)x, (real)y, (real)z);
+ return Vertex(x,y,z);
}
int LevelGridBuilder::getMatrixIndex(int i) const
diff --git a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
index 87099c2a67eb73658b4012f0991b2c6d08ce39ba..e9cbe8defb8efe9022b14f4974f4520ef2952754 100644
--- a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
+++ b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
@@ -63,10 +63,6 @@ protected:
GenerationDevice device;
std::vector<std::shared_ptr<GridWrapper> > gridWrapper;
- std::vector<std::shared_ptr<Transformator>> transformators;
- std::vector<std::vector<BoundingBox<int>> > boxes;
- std::vector<int> rankTasks;
- std::vector<std::vector<int> > gridDimensions;
std::vector<std::vector<std::vector<real> > > Qs;
@@ -74,17 +70,6 @@ protected:
void checkLevel(int level);
-protected:
- virtual void createGridKernels(std::string distribution);
-
- void setNumberOfNodes(real length, real width, real high, real delta);
- void printMasterInformation(int nx, int ny, int nz);
- void setCudaDevice(int rank);
- void rebuildBoxes();
- void sendTasks();
- void receiveTasks();
- void writeBoxes(std::string name);
-
protected:
void createBCVectors();
void addShortQsToVector(int index);
diff --git a/src/GridGenerator/grid/GridBuilder/ParallelGridBuilder.cpp b/src/GridGenerator/grid/GridBuilder/ParallelGridBuilder.cpp
index 9b47d14cd15c25b6f7c3f4ad9e398bf6c97e4892..148834ec11981ddd8ce14172b487a84d0ca4f655 100644
--- a/src/GridGenerator/grid/GridBuilder/ParallelGridBuilder.cpp
+++ b/src/GridGenerator/grid/GridBuilder/ParallelGridBuilder.cpp
@@ -358,12 +358,12 @@ void ParallelGridBuilder::getNodeValues(real *xCoords, real *yCoords, real *zCoo
for (int i = 0; i < grid.reducedSize; i++)
{
- unsigned int x, y, z;
+ real x, y, z;
grid.transIndexToCoords(grid.matrixIndex[i], x, y, z);
- xCoords[i + 1] = (real)x;
- yCoords[i + 1] = (real)y;
- zCoords[i + 1] = (real)z;
+ xCoords[i + 1] = x;
+ yCoords[i + 1] = y;
+ zCoords[i + 1] = z;
neighborX[i + 1] = (unsigned int)(grid.neighborIndexX[grid.matrixIndex[i]] + 1);
neighborY[i + 1] = (unsigned int)(grid.neighborIndexY[grid.matrixIndex[i]] + 1);
neighborZ[i + 1] = (unsigned int)(grid.neighborIndexZ[grid.matrixIndex[i]] + 1);
@@ -416,7 +416,7 @@ void ParallelGridBuilder::createBCVectors()
Grid grid = this->gridKernels[0][0]->grid;
for (int i = 0; i < grid.reducedSize; i++)
{
- unsigned int x, y, z;
+ real x, y, z;
grid.transIndexToCoords(grid.matrixIndex[i], x, y, z);
if (grid.field[grid.matrixIndex[i]] == Q) /*addShortQsToVector(i);*/ addQsToVector(i);
@@ -528,7 +528,7 @@ void ParallelGridBuilder::writeArrow(const int i, const int qi, const Vertex& st
Vertex ParallelGridBuilder::getVertex(int matrixIndex) const
{
- unsigned int x, y, z;
+ real x, y, z;
this->gridKernels[0][0]->grid.transIndexToCoords(matrixIndex, x, y, z);
return Vertex((real)x, (real)y, (real)z);
}
diff --git a/src/GridGenerator/grid/GridTest.cpp b/src/GridGenerator/grid/GridTest.cpp
index 06d749f0f27be0965df4a2fdde5a39a119979f6b..0b8f0c72b44c5aa990fb6a7dc6b9ac5b9d7c44bf 100644
--- a/src/GridGenerator/grid/GridTest.cpp
+++ b/src/GridGenerator/grid/GridTest.cpp
@@ -31,12 +31,12 @@ TEST(GridTest, transIndexToCoordsAndCoordToIndex)
Grid grid(nullptr, 0, 0, 0, 10, 10, 10, Distribution());
int index = 756;
- unsigned int x, y, z;
+ real x, y, z;
grid.transIndexToCoords(index, x, y, z);
- unsigned int expectedX = 6;
- unsigned int expectedY = 5;
- unsigned int expectedZ = 7;
+ real expectedX = 6;
+ real expectedY = 5;
+ real expectedZ = 7;
EXPECT_THAT(x, expectedX);
EXPECT_THAT(y, expectedY);
@@ -203,4 +203,19 @@ TEST_F(GridStopperTest, testIfNodeIsStopper_IfMinusXZisFluid_ItShouldBeAStopperN
grid.field[grid.transCoordToIndex(0, 1, 0)] = FLUID; // -xz
ASSERT_TRUE(grid.isStopper(grid.transCoordToIndex(1, 1, 1)));
-}
\ No newline at end of file
+}
+
+TEST(GridTest, transRealCoordsToIndex)
+{
+ Grid grid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, 0.5, Distribution());
+
+ Vertex v(1.5, 0.0, 0.0);
+
+ unsigned int index = grid.transCoordToIndex(v);
+
+ EXPECT_THAT(index, testing::Eq(3));
+
+ real x, y, z;
+ grid.transIndexToCoords(index, x,y,z );
+
+}
diff --git a/src/GridGenerator/grid/distributions/Distribution.cpp b/src/GridGenerator/grid/distributions/Distribution.cpp
index 07b59acea3ab3af19e55da84295823f93bd36581..ffd94931810674d1a4372abfd9e813b0bd365318 100644
--- a/src/GridGenerator/grid/distributions/Distribution.cpp
+++ b/src/GridGenerator/grid/distributions/Distribution.cpp
@@ -357,9 +357,9 @@ std::vector<std::vector<real> > DistributionHelper::getAllQsOnFluidNodes(const G
int DistributionHelper::getNeighborNodeIndexInGivenDirection(const Distribution &d, const Grid &grid, const int node, const int dir_index)
{
Vertex dir = Vertex((real)d.dirs[dir_index * DIMENSION + 0], (real)d.dirs[dir_index * DIMENSION + 1], (real)d.dirs[dir_index * DIMENSION + 2]);
- unsigned int x, y, z;
+ real x, y, z;
grid.transIndexToCoords(node, x, y, z);
- Vertex solid_node = Vertex((real)x, (real)y,(real)z);
+ Vertex solid_node = Vertex(x,y,z);
Vertex fluid_node = Vertex(solid_node.x - dir.x, solid_node.y - dir.y, solid_node.z - dir.z);
return grid.transCoordToIndex(fluid_node);
}
diff --git a/src/GridGenerator/grid/partition/Partition.cpp b/src/GridGenerator/grid/partition/Partition.cpp
index 03d75beb4c5b565330310955f03d726147d0e4b4..76a50f3dc99a7b6005de0f14bf5a7169c969800b 100644
--- a/src/GridGenerator/grid/partition/Partition.cpp
+++ b/src/GridGenerator/grid/partition/Partition.cpp
@@ -52,7 +52,7 @@ void Partition::partitionGridMesh(const Grid &grid)
// Adjacent vertices in consecutive index order
idx_t *eind = new idx_t[nNodes];
- unsigned int x, y, z, newX, newY, newZ;
+ real x, y, z, newX, newY, newZ;
int nIndex;
int numberNode = 0;
for (unsigned int index = 0; index < grid.size; index++) {
@@ -155,7 +155,7 @@ void Partition::partitionGrid(const Grid &grid) {
idx_t* adjncy = new idx_t[nEdges];
xadj[0] = 0;
- unsigned int x, y, z, newX, newY, newZ;
+ real x, y, z, newX, newY, newZ;
int nIndex;
int numberOfNeighbors = 0;
int counter = 0;
diff --git a/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp b/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp
index 4f20f7cc3adcf3766447a41fd1206c7a71c0c9f4..c3199decec6a560c46221868713671a847ff4adc 100644
--- a/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp
+++ b/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp
@@ -86,20 +86,37 @@ void GridVTKWriter::writeHeader()
void GridVTKWriter::writePoints(std::shared_ptr<const Transformator> trans, const struct Grid &grid, const unsigned int &size)
{
fprintf(file, "POINTS %d float\n", size);
-
- unsigned int x, y, z;
- for (unsigned int i = 0; i < size; i++) {
- grid.transIndexToCoords(grid.matrixIndex[i], x, y, z);
- Vertex v((real)x, (real)y, (real)z);
- trans->transformGridToWorld(v);
- if (binaer) {
- write_float((float)v.x);
- write_float((float)v.y);
- write_float((float)v.z);
+ int counter = 0;
+ for (real x = grid.sX; x <= grid.eX; x += grid.delta) {
+ for (real y = grid.sY; y <= grid.eY; y += grid.delta) {
+ for (real z = grid.sZ; z <= grid.eZ; z += grid.delta) {
+ counter++;
+ Vertex v(x,y,z);
+ trans->transformGridToWorld(v);
+ if (binaer) {
+ write_float((float)v.x);
+ write_float((float)v.y);
+ write_float((float)v.z);
+ }
+ else
+ fprintf(file, "%f %f %f\n", v.x, v.y, v.z);
+ }
}
- else
- fprintf(file, "%f %f %f\n", v.x, v.y, v.z);
}
+
+ //unsigned int x, y, z;
+ //for (unsigned int i = 0; i < size; i++) {
+ // grid.transIndexToCoords(grid.matrixIndex[i], x, y, z);
+ // Vertex v((real)x, (real)y, (real)z);
+ // trans->transformGridToWorld(v);
+ // if (binaer) {
+ // write_float((float)v.x);
+ // write_float((float)v.y);
+ // write_float((float)v.z);
+ // }
+ // else
+ // fprintf(file, "%f %f %f\n", v.x, v.y, v.z);
+ //}
}
void GridVTKWriter::writeCells(const unsigned int &size)
@@ -136,11 +153,16 @@ void GridVTKWriter::writeTypeHeader(const unsigned int &size)
void GridVTKWriter::writeTypes(const Grid &grid, const unsigned int &size)
{
- for (unsigned int i = 0; i < size; i++) {
- if (binaer)
- write_int(grid.field[grid.matrixIndex[i]]);
- else
- fprintf(file, "%d ", grid.field[grid.matrixIndex[i]]);
+
+ for (real x = grid.sX; x <= grid.eX; x += grid.delta) {
+ for (real y = grid.sY; y <= grid.eY; y += grid.delta) {
+ for (real z = grid.sZ; z <= grid.eZ; z += grid.delta) {
+ if (binaer)
+ write_int(grid.field[grid.transCoordToIndex(x,y,z)]);
+ else
+ fprintf(file, "%d ", grid.field[grid.transCoordToIndex(x, y, z)]);
+ }
+ }
}
}
diff --git a/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.h b/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.h
index 0456c6b27e3b4914ab153a8e14e4b97a6022dd75..cb55eac69c989ab3534e7ff73fcd3c2d182a552e 100644
--- a/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.h
+++ b/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.h
@@ -4,6 +4,9 @@
#include <string>
#include <memory>
+#include <GridGenerator/utilities/Transformator/TransformatorImp.h>
+
+
#include <VirtualFluidsDefinitions.h>
class Transformator;
@@ -12,8 +15,8 @@ struct Grid;
class VF_PUBLIC GridVTKWriter
{
public:
- static void writeGridToVTK(const Grid &grid, std::string name, std::shared_ptr<const Transformator> trans, bool binaer = true);
- static void writeSparseGridToVTK(const Grid &grid, std::string name, std::shared_ptr<const Transformator> trans, bool binaer = false);
+ static void writeGridToVTK(const Grid &grid, std::string name, std::shared_ptr<const Transformator> trans = std::make_shared<TransformatorImp>(), bool binaer = true);
+ static void writeSparseGridToVTK(const Grid &grid, std::string name, std::shared_ptr<const Transformator> trans = std::make_shared<TransformatorImp>(), bool binaer = false);
private:
GridVTKWriter();
diff --git a/src/GridGenerator/io/STLReaderWriter/STLReader.cpp b/src/GridGenerator/io/STLReaderWriter/STLReader.cpp
index eb5bba0932ce3947b10eddf192d16b92f65ec603..757cdeb864b170ed6a2d9347be619da52f392b94 100644
--- a/src/GridGenerator/io/STLReaderWriter/STLReader.cpp
+++ b/src/GridGenerator/io/STLReaderWriter/STLReader.cpp
@@ -6,7 +6,7 @@
#include <string>
#include <stdio.h>
-#include <GridGenerator/utilities/Transformator/Transformator.h>
+#include <GridGenerator/utilities/Transformator/TransformatorImp.h>
#include <GridGenerator/geometries/Vertex/Vertex.cuh>
#include <GridGenerator/geometries/Triangle/Triangle.cuh>
#include <GridGenerator/geometries/BoundingBox/BoundingBox.cuh>
@@ -14,6 +14,32 @@
#include <utilities/logger/Logger.h>
+
+std::vector<Triangle> STLReader::readSTL(const std::string& name)
+{
+ TransformatorImp trans;
+ std::ifstream file(name.c_str());
+ if (file.is_open()) {
+ std::string line;
+ std::getline(file, line);
+ line[strcspn(line.c_str(), "\r\n")] = 0;
+ if (strcmp(line.c_str(), "solid ascii") == 0) {
+ file.close();
+ *logging::out << logging::Logger::INTERMEDIATE << "start reading ascii STL file: " + name + "\n";
+ return readASCIISTL(name, trans);
+ }
+ else {
+ file.close();
+ *logging::out << logging::Logger::INTERMEDIATE << "start reading binary STL file: " + name + "\n";
+ return readBinarySTL(name, trans);
+ }
+ }
+ else {
+ *logging::out << logging::Logger::INTERMEDIATE << "can't open STL-file" + name + "\n";
+ exit(1);
+ }
+}
+
std::vector<Triangle> STLReader::readSTL(const std::string& name, const Transformator& trans)
{
std::ifstream file(name.c_str());
diff --git a/src/GridGenerator/io/STLReaderWriter/STLReader.h b/src/GridGenerator/io/STLReaderWriter/STLReader.h
index dd246462650cfd2a99f799936f4efda9b761b127..44ce0d319c73f749833df480a24e0fe874a25a15 100644
--- a/src/GridGenerator/io/STLReaderWriter/STLReader.h
+++ b/src/GridGenerator/io/STLReaderWriter/STLReader.h
@@ -19,6 +19,7 @@ struct Geometry;
class VF_PUBLIC STLReader
{
public:
+ static std::vector<Triangle> readSTL(const std::string& name);
static std::vector<Triangle> readSTL(const std::string& name, const Transformator& trans);
static std::vector<Triangle> readSTL(const BoundingBox<int> &box, const std::string name, const Transformator& trans);
diff --git a/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp b/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp
index e0661f340d5e1c918474830e599851055061a741..8297282c0276eb3e5e339fedda75f6a8b4817dcb 100644
--- a/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp
+++ b/src/GridGenerator/io/SimulationFileWriter/SimulationFileWriter.cpp
@@ -125,10 +125,10 @@ void SimulationFileWriter::writeCoordsNeighborsGeo(const int& i, bool binaer, st
int index = grid.matrixIndex[i];
int type = grid.field[index] == SOLID ? 16 : 1;
- unsigned int x, y, z;
+ real x, y, z;
grid.transIndexToCoords(index, x, y, z);
- Vertex v = Vertex((real)x, (real)y, (real)z);
+ Vertex v = Vertex(x, y, z);
trans->transformGridToWorld(v);
double xWorld = v.x;
double yWorld = v.y;
diff --git a/src/core/PointerDefinitions.h b/src/core/PointerDefinitions.h
index 849fa450005135d8f6702e5e37f42d2c75c2262f..687dbfefe552b4595daf16a5e6a658c4e79b4a74 100644
--- a/src/core/PointerDefinitions.h
+++ b/src/core/PointerDefinitions.h
@@ -7,6 +7,7 @@
#include <memory>
+
template <class T>
using SPtr = std::shared_ptr<T>;
diff --git a/targets/apps/HULC/main.cpp b/targets/apps/HULC/main.cpp
index ee73e1a99e1c2b3ec9bc5b38abd7f48b33ddc2c2..3871a160673b71657e6846fcb7a9fb3e8dc89f25 100644
--- a/targets/apps/HULC/main.cpp
+++ b/targets/apps/HULC/main.cpp
@@ -15,14 +15,14 @@
#include "DataStructureInitializer/GridProvider.h"
#include "VirtualFluidsBasics/utilities/input/Input.h"
#include "VirtualFluidsBasics/utilities/StringUtil/StringUtil.h"
-#include "grid/GridBuilder/GridBuilderImp.h"
+#include "grid/GridBuilder/LevelGridBuilder.h"
#include "utilities/transformator/TransformatorImp.h"
#include "io/GridVTKWriter/GridVTKWriter.h"
#include "grid/GridWrapper/GridWrapper.h"
#include "io/SimulationFileWriter/SimulationFileWriter.h"
-#include "VirtualFluidsBasics/numerics/geometry3d/GbCuboid3D.h"
#include "grid/GridBuilder/LevelGridBuilder.h"
-
+#include "grid/GridBuilder/ParallelGridBuilder.h"
+#include "geometries/Geometry/Geometry.cuh"
std::string getGridPath(std::shared_ptr<Parameter> para, std::string Gridpath)
{
@@ -229,32 +229,48 @@ void setParameters(std::shared_ptr<Parameter> para, std::unique_ptr<input::Input
void multipleLevel(const std::string& configPath)
{
+ Grid grid(35, 3, -5, 70, 40, 25, 0.5, Distribution());
- SPtr<GridBuilder> builder(new LevelGridBuilder(GridBuilder::GenerationDevice::CPU));
- builder->addGrid(0.0, 0.0, 0.0, 64.0, 12.0, 96.0, "D3Q27");
- builder->addGrid(20.0, 4.0, 40.0, 40.0, 8.0, 60.0, "D3Q27");
+ for (unsigned int index = 0; index < grid.size; index++)
+ {
+ grid.setNeighborIndices(index);
+ grid.matrixIndex[index] = index;
+ grid.setFieldEntryToFluid(index);
+ }
+ //grid.field[grid.transCoordToIndex(30, 10, 20)] = 11;
+ //real x, y, z;
+ //grid.transIndexToCoords(grid.transCoordToIndex(30, 10, 20), x, y, z);
- SPtr<Parameter> para = Parameter::make();
- SPtr<GridProvider> gridGenerator = GridProvider::makeGridGenerator(builder, para);
+ Geometry* geometry = new Geometry("D:/GRIDGENERATION/STL/circleBinaer.stl");
+ for (int i = 0; i < geometry->size; i++)
+ grid.meshTriangleExact(geometry->triangles[i]);
+ delete geometry;
- std::ifstream stream;
- stream.open(configPath.c_str(), std::ios::in);
- if (stream.fail())
- throw "can not open config file!\n";
- UPtr<input::Input> input = input::Input::makeInput(stream, "config");
+ GridVTKWriter::writeGridToVTK(grid, "D:/GRIDGENERATION/gridTest");
- setParameters(para, input);
+ //SPtr<Parameter> para = Parameter::make();
+ //SPtr<GridProvider> gridGenerator = GridProvider::makeGridGenerator(builder, para);
- Simulation sim;
- sim.init(para, gridGenerator);
- sim.run();
+ //std::ifstream stream;
+ //stream.open(configPath.c_str(), std::ios::in);
+ //if (stream.fail())
+ // throw "can not open config file!\n";
+
+ //UPtr<input::Input> input = input::Input::makeInput(stream, "config");
+
+ //setParameters(para, input);
+
+ //Simulation sim;
+ //sim.init(para, gridGenerator);
+ //sim.run();
}
void simulate(const std::string& configPath)
{
- SPtr<GridBuilder> builder = GridBuilderImp::make("gpu");
+ SPtr<ParallelGridBuilder> builder(new ParallelGridBuilder(GridBuilder::GenerationDevice::CPU));
+
SPtr<Parameter> para = Parameter::make();
SPtr<GridProvider> gridGenerator = GridProvider::makeGridGenerator(builder, para);
@@ -298,7 +314,7 @@ int main( int argc, char* argv[])
str2 = static_cast<std::string>(argv[1]);
try
{
- simulate(str2);
+ multipleLevel(str2);
}
catch (std::string e)
{