From a80e35b6a50c93372a3bb8c5a3b17dd02a488524 Mon Sep 17 00:00:00 2001
From: Soeren Peters <peters@irmb.tu-bs.de>
Date: Mon, 23 Apr 2018 12:49:10 +0200
Subject: [PATCH] - creates TriangularMeshStrategy
---
.../TriangularMesh/TriangularMesh.cu | 19 ++
.../TriangularMesh/TriangularMesh.h | 6 +-
.../TriangularMesh/TriangularMeshStrategy.h | 297 ++++++++++++++++++
src/GridGenerator/grid/GridFactory.h | 39 ++-
src/GridGenerator/grid/GridImp.cu | 26 +-
src/GridGenerator/grid/GridImp.h | 16 +-
.../GridCpuStrategy/GridCpuStrategy.cpp | 1 -
targets/apps/HULC/CMakeLists.txt | 2 +-
targets/apps/HULC/main.cpp | 3 +
.../tests/GridGeneratorTest/CMakeLists.txt | 2 +-
10 files changed, 395 insertions(+), 16 deletions(-)
create mode 100644 src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h
diff --git a/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu b/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
index d2d14884a..83d69eef0 100644
--- a/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
+++ b/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.cu
@@ -9,6 +9,8 @@
#include "Timer/Timer.h"
+#include "numerics/geometry3d/GbTriFaceMesh3D.h"
+
TriangularMesh* TriangularMesh::make(const std::string& fileName, DiscretizationMethod discretizationMethod)
{
@@ -96,4 +98,21 @@ HOST bool TriangularMesh::operator==(const TriangularMesh &geometry) const
HOST DiscretizationMethod TriangularMesh::getDiscretizationMethod() const
{
return this->discretizationMethod;
+}
+
+HOSTDEVICE GbTriFaceMesh3D* TriangularMesh::getGbTriFaceMesh3D() const
+{
+ std::vector<GbTriFaceMesh3D::Vertex> *gbVertices = new std::vector<GbTriFaceMesh3D::Vertex>(this->triangleVec.size() * 3);
+ std::vector<GbTriFaceMesh3D::TriFace> *gbTriangles = new std::vector<GbTriFaceMesh3D::TriFace>(this->triangleVec.size());
+ for (int i = 0; i < this->triangleVec.size(); i++)
+ {
+ (*gbVertices)[i * 3] = GbTriFaceMesh3D::Vertex(triangles[i].v1.x, triangles[i].v1.y, triangles[i].v1.z);
+ (*gbVertices)[i * 3 + 1] = GbTriFaceMesh3D::Vertex(triangles[i].v2.x, triangles[i].v2.y, triangles[i].v2.z);
+ (*gbVertices)[i * 3 + 2] = GbTriFaceMesh3D::Vertex(triangles[i].v3.x, triangles[i].v3.y, triangles[i].v3.z);
+
+ (*gbTriangles)[i] = GbTriFaceMesh3D::TriFace(i * 3, i * 3 + 1, i * 3 + 2);
+ }
+
+ GbTriFaceMesh3D* mesh = new GbTriFaceMesh3D("stl", gbVertices, gbTriangles);
+ return mesh;
}
\ No newline at end of file
diff --git a/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.h b/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
index 06e5bfb3d..aa94b9678 100644
--- a/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
+++ b/src/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
@@ -16,6 +16,7 @@
#include "../Object.h"
class GeometryMemento;
+class GbTriFaceMesh3D;
enum class DiscretizationMethod { RAYCASTING, POINT_IN_OBJECT, POINT_UNDER_TRIANGLE };
@@ -40,12 +41,11 @@ public:
HOST VF_PUBLIC bool operator==(const TriangularMesh &geometry) const;
- HOST VF_PUBLIC GeometryMemento getState() const;
- HOST VF_PUBLIC void setState(const GeometryMemento &memento);
+
VF_PUBLIC void findNeighbors();
HOST VF_PUBLIC DiscretizationMethod getDiscretizationMethod() const;
-
+ HOSTDEVICE VF_PUBLIC GbTriFaceMesh3D* getGbTriFaceMesh3D() const;
private:
diff --git a/src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h b/src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h
new file mode 100644
index 000000000..7b4777704
--- /dev/null
+++ b/src/GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h
@@ -0,0 +1,297 @@
+#ifndef TriangularMeshStrategy_H
+#define TriangularMeshStrategy_H
+
+#include "GridGenerator/global.h"
+
+
+
+#include "../Triangle/Triangle.h"
+#include "TriangularMesh.h"
+#include "numerics/geometry3d/GbTriFaceMesh3D.h"
+#include "grid/GridImp.h"
+#include "utilities/logger/Logger.h"
+#include "grid/NodeValues.h"
+
+
+
+
+class TriangularMeshDiscretizationStrategy
+{
+public:
+ TriangularMeshDiscretizationStrategy() {}
+ virtual ~TriangularMeshDiscretizationStrategy() {}
+
+
+ void discretize(TriangularMesh* triangularMesh, GridImp* grid, char InnerType, char OuterType)
+ {
+ this->doDiscretize(triangularMesh, grid, InnerType, OuterType);
+ this->removeOddBoundaryCellNodes(grid);
+ }
+
+private:
+ virtual void doDiscretize(TriangularMesh* triangularMesh, GridImp* grid, char InnerType, char OuterType) = 0;
+ void removeOddBoundaryCellNodes(GridImp* grid)
+ {
+#pragma omp parallel for
+ for (uint index = 0; index < grid->getSize(); index++)
+ grid->removeOddBoundaryCellNode(index);
+ }
+
+
+};
+
+
+
+class PointInObjectDiscretizationStrategy : public TriangularMeshDiscretizationStrategy
+{
+public:
+ PointInObjectDiscretizationStrategy() {}
+ virtual ~PointInObjectDiscretizationStrategy() {}
+
+ virtual void doDiscretize(TriangularMesh* triangularMesh, GridImp* grid, char InnerType, char OuterType)
+ {
+ auto mesh = triangularMesh->getGbTriFaceMesh3D();
+
+ for (int i = 0; i < grid->getSize(); i++)
+ {
+ real x, y, z;
+ grid->transIndexToCoords(i, x, y, z);
+
+ if (mesh->isPointInGbObject3D(x, y, z))
+ grid->setNodeTo(i, InnerType);
+ //else
+ // grid->setNodeTo(i, OuterType);
+ }
+
+ delete mesh;
+ }
+};
+
+class RayCastingDiscretizationStrategy : public TriangularMeshDiscretizationStrategy
+{
+public:
+ RayCastingDiscretizationStrategy() {}
+ virtual ~RayCastingDiscretizationStrategy() {}
+
+ virtual void doDiscretize(TriangularMesh* triangularMesh, GridImp* grid, char InnerType, char OuterType)
+ {
+ auto mesh = triangularMesh->getGbTriFaceMesh3D();
+
+ const real minXExact = triangularMesh->minmax.minX;
+ const real minYExact = triangularMesh->minmax.minY;
+ const real minZExact = triangularMesh->minmax.minZ;
+
+ const real maxXExact = triangularMesh->minmax.maxX;
+ const real maxYExact = triangularMesh->minmax.maxY;
+ const real maxZExact = triangularMesh->minmax.maxZ;
+
+ const auto min = grid->getMinimumOnNode(Vertex(minXExact, minYExact, minZExact));
+
+ const real minX = min.x;
+ const real minY = min.y;
+ const real minZ = min.z;
+
+ const auto max = grid->getMaximumOnNode(Vertex(maxXExact, maxYExact, maxZExact));
+
+ const real maxX = max.x;
+ const real maxY = max.y;
+ const real maxZ = max.z;
+
+
+ for (uint i = 0; i < grid->getSize(); i++)
+ grid->setNodeTo(i, InnerType);
+
+ int counter = 0;
+
+ real x, y, z;
+ // Test line intersection
+ for (z = minZ; z <= maxZ; z += grid->getDelta())
+ {
+ for (y = minY; y <= maxY; y += grid->getDelta())
+ {
+ for (x = minX; x <= maxX; x += grid->getDelta())
+ {
+ counter++;
+ if (mesh->intersectLine((x - grid->getDelta()), y, z, x, y, z))
+ break;
+ grid->setNodeTo(grid->transCoordToIndex(x, y, z), OuterType);
+ }
+ }
+ }
+
+ // Test line intersection from opposite direction
+ for (z = minZ; z <= maxZ; z += grid->getDelta())
+ {
+ for (y = minY; y <= maxY; y += grid->getDelta())
+ {
+ for (x = maxX; x >= minX; x -= grid->getDelta())
+ {
+ if (!grid->isNode(grid->transCoordToIndex(x, y, z), OuterType))
+ {
+ counter++;
+ if (mesh->intersectLine((x + grid->getDelta()), y, z, x, y, z))
+ break;
+ grid->setNodeTo(grid->transCoordToIndex(x, y, z), OuterType);
+ }
+ }
+ }
+ }
+
+ // Test line intersection
+ for (z = minZ; z <= maxZ; z += grid->getDelta())
+ {
+ for (x = minX; x <= maxX; x += grid->getDelta())
+ {
+ for (y = minY; y <= maxY; y += grid->getDelta())
+ {
+ if (!grid->isNode(grid->transCoordToIndex(x, y, z), OuterType))
+ {
+ counter++;
+ if (mesh->intersectLine(x, (y - grid->getDelta()), z, x, y, z))
+ break;
+ grid->setNodeTo(grid->transCoordToIndex(x, y, z), OuterType);
+ }
+ }
+ }
+ }
+
+ // Test line intersection from opposite direction
+ for (z = minZ; z <= maxZ; z += grid->getDelta())
+ {
+ for (x = minX; x <= maxX; x += grid->getDelta())
+ {
+ for (y = maxY; y >= minY; y -= grid->getDelta())
+ {
+ if (!grid->isNode(grid->transCoordToIndex(x, y, z), OuterType))
+ {
+ counter++;
+ if (mesh->intersectLine(x, (y + grid->getDelta()), z, x, y, z))
+ break;
+ grid->setNodeTo(grid->transCoordToIndex(x, y, z), OuterType);
+ }
+ }
+ }
+ }
+
+ // Test line intersection
+ for (x = minX; x <= maxX; x += grid->getDelta())
+ {
+ for (y = minY; y <= maxY; y += grid->getDelta())
+ {
+ for (z = minZ; z <= maxZ; z += grid->getDelta())
+ {
+ if (!grid->isNode(grid->transCoordToIndex(x, y, z), OuterType))
+ {
+ counter++;
+ if (mesh->intersectLine(x, y, (z - grid->getDelta()), x, y, z))
+ break;
+ grid->setNodeTo(grid->transCoordToIndex(x, y, z), OuterType);
+ }
+ }
+ }
+ }
+
+ // Test line intersection from opposite direction
+ for (x = minX; x <= maxX; x += grid->getDelta())
+ {
+ for (y = minY; y <= maxY; y += grid->getDelta())
+ {
+ for (z = maxZ; z >= minZ; z -= grid->getDelta())
+ {
+ if (!grid->isNode(grid->transCoordToIndex(x, y, z), OuterType))
+ {
+ counter++;
+ if (mesh->intersectLine(x, y, (z + grid->getDelta()), x, y, z))
+ break;
+ grid->setNodeTo(grid->transCoordToIndex(x, y, z), OuterType);
+ }
+ }
+ }
+ }
+
+ delete mesh;
+ }
+};
+
+class PointUnderTriangleStrategy : public TriangularMeshDiscretizationStrategy
+{
+public:
+ PointUnderTriangleStrategy() {}
+ virtual ~PointUnderTriangleStrategy() {}
+ void doDiscretize(TriangularMesh* triangularMesh, GridImp* grid, char innerType, char outerType) override
+ {
+#pragma omp parallel for
+ for (uint i = 0; i < triangularMesh->size; i++)
+ this->meshReverse(triangularMesh->triangles[i], grid, innerType);
+
+ this->findInsideNodes(grid, innerType);
+
+#pragma omp parallel for
+ for (uint i = 0; i < grid->getSize(); i++)
+ this->setNegativeDirBorderTo(grid, i, innerType);
+ }
+
+private:
+ HOSTDEVICE void meshReverse(Triangle &triangle, GridImp* grid, char innerType)
+ {
+ auto box = grid->getBoundingBoxOnNodes(triangle);
+
+ const real delta = grid->getDelta();
+ triangle.initalLayerThickness(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)
+ {
+ const uint index = grid->transCoordToIndex(x, y, z);
+
+ const Vertex point(x, y, z);
+
+ const char pointValue = triangle.isUnderFace(point);
+
+ if (pointValue == NEGATIVE_DIRECTION_BORDER)
+ grid->setNodeTo(index, NEGATIVE_DIRECTION_BORDER);
+ else if (pointValue == INSIDE)
+ grid->setNodeTo(index, innerType);
+ }
+ }
+ }
+ }
+
+ HOSTDEVICE void findInsideNodes(GridImp* grid, char innerType)
+ {
+ bool foundInsideNode = true;
+ while (foundInsideNode)
+ {
+ foundInsideNode = false;
+ for (uint index = 0; index < grid->getSize(); index++)
+ this->setInsideNode(grid, index, foundInsideNode, innerType);
+ }
+ }
+
+ HOSTDEVICE void setInsideNode(GridImp* grid, const uint &index, bool &insideNodeFound, char innerType)
+ {
+ if (grid->isNode(index, NEGATIVE_DIRECTION_BORDER))
+ return;
+
+ if (!grid->isNode(index, innerType) && grid->nodeInNextCellIs(index, innerType))
+ {
+ grid->setNodeTo(index, innerType);
+ insideNodeFound = true;
+ }
+ }
+
+ HOSTDEVICE void setNegativeDirBorderTo(GridImp* grid, const uint &index, char innerType)
+ {
+ if (grid->isNode(index, NEGATIVE_DIRECTION_BORDER))
+ grid->setNodeTo(index, innerType);
+ }
+
+};
+
+
+
+#endif
+
diff --git a/src/GridGenerator/grid/GridFactory.h b/src/GridGenerator/grid/GridFactory.h
index ed68f052b..dca8e2c73 100644
--- a/src/GridGenerator/grid/GridFactory.h
+++ b/src/GridGenerator/grid/GridFactory.h
@@ -11,28 +11,46 @@
#include "GridMocks.h"
#include "geometries/Cuboid/Cuboid.h"
#include "geometries/Sphere/Sphere.h"
+#include "geometries/TriangularMesh/TriangularMeshStrategy.h"
enum class Device
{
CPU, GPU
};
+enum class TriangularMeshDiscretizationMethod
+{
+ RAYCASTING, POINT_IN_OBJECT, POINT_UNDER_TRIANGLE
+};
+
+
+class TriangularMeshDiscretizationStrategyFactory
+{
+public:
+
+};
class VF_PUBLIC GridFactory
{
public:
SPtr<Grid> makeGrid(Object* gridShape, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, const std::string& d3Qxx = "D3Q27")
{
+
if (!gridStrategy)
throw "GridStrategy has to be set before make Grid!";
Distribution distribution = DistributionHelper::getDistribution(d3Qxx);
+
+
if(this->grid == "stub")
return GridStub::makeShared(gridShape, delta, gridStrategy, distribution);
else if(this->grid == "spy")
- return GridSpy::makeShared(gridShape, delta, gridStrategy, distribution);
+ return GridSpy::makeShared(gridShape, delta, gridStrategy, distribution);
- return GridImp::makeShared(gridShape, startX, startY, startZ, endX, endY, endZ, delta, gridStrategy, distribution);
+ SPtr<GridImp> grid = GridImp::makeShared(gridShape, startX, startY, startZ, endX, endY, endZ, delta, gridStrategy, distribution);
+ grid->setTriangularMeshDiscretizationStrategy(this->triangularMeshDiscretizationStrategy);
+
+ return grid;
}
@@ -57,7 +75,24 @@ public:
this->grid = grid;
}
+ void setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod triangularMeshDiscretizationMethod)
+ {
+ switch (triangularMeshDiscretizationMethod)
+ {
+ case TriangularMeshDiscretizationMethod::POINT_UNDER_TRIANGLE:
+ triangularMeshDiscretizationStrategy = new PointUnderTriangleStrategy();
+ break;
+ case TriangularMeshDiscretizationMethod::RAYCASTING:
+ triangularMeshDiscretizationStrategy = new RayCastingDiscretizationStrategy();
+ break;
+ case TriangularMeshDiscretizationMethod::POINT_IN_OBJECT:
+ triangularMeshDiscretizationStrategy = new PointInObjectDiscretizationStrategy();
+ break;
+ }
+ }
+
private:
+ TriangularMeshDiscretizationStrategy* triangularMeshDiscretizationStrategy;
SPtr<GridStrategy> gridStrategy;
std::string grid;
};
diff --git a/src/GridGenerator/grid/GridImp.cu b/src/GridGenerator/grid/GridImp.cu
index 51d1ea9c9..17f132f18 100644
--- a/src/GridGenerator/grid/GridImp.cu
+++ b/src/GridGenerator/grid/GridImp.cu
@@ -13,6 +13,8 @@
#include <GridGenerator/geometries/Vertex/Vertex.h>
#include <GridGenerator/geometries/Triangle/Triangle.h>
#include <GridGenerator/geometries/TriangularMesh/TriangularMesh.h>
+#include <GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h>
+
#include <GridGenerator/geometries/BoundingBox/BoundingBox.h>
#include <GridGenerator/grid/NodeValues.h>
@@ -70,8 +72,9 @@ HOST void GridImp::inital()
gridStrategy->initalNodesToOutOfGrid(shared_from_this());
TriangularMesh* triangularMesh = dynamic_cast<TriangularMesh*>(object);
- if(triangularMesh)
- gridStrategy->findInnerNodes(shared_from_this(), triangularMesh);
+ if (triangularMesh)
+ triangularMeshDiscretizationStrategy->discretize(triangularMesh, this, FLUID, OUT_OF_GRID);
+ //gridStrategy->findInnerNodes(shared_from_this(), triangularMesh);
else
gridStrategy->findInnerNodes(shared_from_this());
@@ -207,7 +210,7 @@ HOSTDEVICE void GridImp::removeOddBoundaryCellNode(uint index)
if (isOutSideOfGrid(cell))
return;
if (contains(cell, OUT_OF_GRID))
- setTo(cell, OUT_OF_GRID);
+ setNodeTo(cell, OUT_OF_GRID);
}
HOSTDEVICE bool GridImp::isOutSideOfGrid(Cell &cell) const
@@ -230,13 +233,24 @@ HOSTDEVICE bool GridImp::contains(Cell &cell, char type) const
return false;
}
-HOSTDEVICE void GridImp::setTo(Cell &cell, char type)
+HOSTDEVICE void GridImp::setNodeTo(Cell &cell, char type)
{
for (const auto point : cell) {
field.setFieldEntry(transCoordToIndex(point.x, point.y, point.z), type);
}
}
+HOSTDEVICE void GridImp::setNodeTo(uint index, char type)
+{
+ field.setFieldEntry(index, type);
+}
+
+HOSTDEVICE bool GridImp::isNode(uint index, char type) const
+{
+ return field.is(index, type);
+}
+
+
HOSTDEVICE bool GridImp::isValidStartOfGridStopper(uint index) const
{
return this->field.is(index, OUT_OF_GRID) && (nodeInNextCellIs(index, FLUID) || nodeInNextCellIs(index, FLUID_CFF));
@@ -385,6 +399,10 @@ HOST uint GridImp::getLevel(real startDelta) const
return level;
}
+HOST void GridImp::setTriangularMeshDiscretizationStrategy(TriangularMeshDiscretizationStrategy* triangularMeshDiscretizationStrategy)
+{
+ this->triangularMeshDiscretizationStrategy = triangularMeshDiscretizationStrategy;
+}
// --------------------------------------------------------- //
// Set Sparse Indices //
diff --git a/src/GridGenerator/grid/GridImp.h b/src/GridGenerator/grid/GridImp.h
index 7019158a9..ff7615739 100644
--- a/src/GridGenerator/grid/GridImp.h
+++ b/src/GridGenerator/grid/GridImp.h
@@ -16,6 +16,7 @@ class GridStrategy;
class GridInterface;
class Object;
class BoundingBox;
+class TriangularMeshDiscretizationStrategy;
extern CONSTANT int DIRECTIONS[DIR_END_MAX][DIMENSION];
@@ -34,12 +35,10 @@ private:
HOSTDEVICE Cell getOddCellFromIndex(uint index) const;
HOSTDEVICE bool isValidStartOfGridStopper(uint index) const;
HOSTDEVICE bool isValidEndOfGridStopper(uint index) const;
- HOSTDEVICE void removeOddBoundaryCellNode(uint index);
HOSTDEVICE bool isOutSideOfGrid(Cell &cell) const;
HOSTDEVICE bool contains(Cell &cell, char type) const;
- HOSTDEVICE void setTo(Cell &cell, char type);
+ HOSTDEVICE void setNodeTo(Cell &cell, char type);
- HOSTDEVICE bool nodeInNextCellIs(int index, char type) const;
HOSTDEVICE bool nodeInPreviousCellIs(int index, char type) const;
HOSTDEVICE bool nodeInCellIs(Cell& cell, char type) const override;
@@ -64,10 +63,12 @@ private:
int *neighborIndexX, *neighborIndexY, *neighborIndexZ;
int *sparseIndices;
SPtr<GridStrategy> gridStrategy;
+ TriangularMeshDiscretizationStrategy* triangularMeshDiscretizationStrategy;
public:
HOST void inital() override;
+ HOSTDEVICE void removeOddBoundaryCellNode(uint index);
HOST void setPeriodicity(bool periodicityX, bool periodicityY, bool periodicityZ) override;
HOSTDEVICE void setCellTo(uint index, char type);
@@ -79,6 +80,8 @@ public:
HOST void freeMemory() override;
HOST uint getLevel(real levelNull) const;
+ HOST void setTriangularMeshDiscretizationStrategy(TriangularMeshDiscretizationStrategy* triangularMeshDiscretizationStrategy);
+
public:
Distribution distribution;
@@ -94,6 +97,9 @@ public:
HOSTDEVICE void findGridInterfaceFC(uint index, GridImp& finerGrid);
HOSTDEVICE void findOverlapStopper(uint index, GridImp& finerGrid);
+ HOSTDEVICE void setNodeTo(uint index, char type);
+ HOSTDEVICE bool isNode(uint index, char type) const;
+ HOSTDEVICE bool nodeInNextCellIs(int index, char type) const;
HOSTDEVICE Field getField() const;
HOSTDEVICE char getFieldEntry(uint index) const override;
@@ -137,6 +143,7 @@ public:
SPtr<GridStrategy> getGridStrategy() const override;
+
HOSTDEVICE void print() const;
@@ -153,11 +160,12 @@ private:
HOSTDEVICE real getFirstFluidNode(real coords[3], int direction, real startCoord) const;
HOSTDEVICE int getSparseIndex(const real &expectedX, const real &expectedY, const real &expectedZ) const;
- HOSTDEVICE BoundingBox GridImp::getBoundingBoxOnNodes(Triangle &triangle) const;
HOSTDEVICE static real getMinimumOnNodes(const real& minExact, const real& decimalStart, const real& delta);
HOSTDEVICE static real getMaximumOnNodes(const real& maxExact, const real& decimalStart, const real& delta);
public:
+ HOSTDEVICE BoundingBox getBoundingBoxOnNodes(Triangle &triangle) const;
+
HOST void mesh(TriangularMesh &geometry) override;
HOSTDEVICE void mesh(Triangle &triangle);
HOSTDEVICE void meshReverse(Triangle &triangle);
diff --git a/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp b/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
index bdfbf8815..0eb72b3ab 100644
--- a/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
+++ b/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
@@ -260,7 +260,6 @@ void GridCpuStrategy::rayCastingMethod(SPtr<GridImp> grid, TriangularMesh* trian
counter++;
if (mesh.intersectLine(x, y, (z + grid->getDelta()), x, y, z)) break;
else grid->field.setFieldEntryToOutOfGrid(grid->transCoordToIndex(x, y, z));
-
}
}
}
diff --git a/targets/apps/HULC/CMakeLists.txt b/targets/apps/HULC/CMakeLists.txt
index fdf315d8d..78c0c2fed 100644
--- a/targets/apps/HULC/CMakeLists.txt
+++ b/targets/apps/HULC/CMakeLists.txt
@@ -2,7 +2,7 @@ setTargetNameToFolderName(${CMAKE_CURRENT_LIST_DIR})
set(linkDirectories "")
set(libsToLink VirtualFluids_GPU GridGenerator)
-set(includeDirectories "${CMAKE_SOURCE_DIR}/src" "${CMAKE_SOURCE_DIR}/src/VirtualFluids_GPU" "${CMAKE_SOURCE_DIR}/src/GridGenerator")
+set(includeDirectories "${CMAKE_SOURCE_DIR}/src" "${CMAKE_SOURCE_DIR}/src/VirtualFluids_GPU" "${CMAKE_SOURCE_DIR}/src/GridGenerator" "${CMAKE_SOURCE_DIR}/src/VirtualFluidsBasics")
#glob files and save in MY_SRCS
include(CMakePackage.cmake)
diff --git a/targets/apps/HULC/main.cpp b/targets/apps/HULC/main.cpp
index 2a637dd79..24548af61 100644
--- a/targets/apps/HULC/main.cpp
+++ b/targets/apps/HULC/main.cpp
@@ -32,6 +32,7 @@
#include "geometries/Conglomerate/Conglomerate.h"
#include "io/STLReaderWriter/STLReader.h"
#include "io/STLReaderWriter/STLWriter.h"
+#include "geometries/TriangularMesh/TriangularMeshStrategy.h"
std::string getGridPath(std::shared_ptr<Parameter> para, std::string Gridpath)
@@ -247,6 +248,8 @@ void multipleLevel(const std::string& configPath)
auto gridFactory = SPtr<GridFactory>(new GridFactory());
gridFactory->setGridStrategy(SPtr<GridStrategy>(new GridCpuStrategy()));
gridFactory->setGrid("grid");
+ gridFactory->setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod::POINT_IN_OBJECT);
+
//auto gridBuilderlevel = LevelGridBuilder::makeShared(Device::CPU, "D3Q27");
auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
gridBuilder->addCoarseGrid(-5.0, -5.0, -5.0, 40.0, 40.0, 40.0, 1.0);
diff --git a/targets/tests/GridGeneratorTest/CMakeLists.txt b/targets/tests/GridGeneratorTest/CMakeLists.txt
index e40a48a82..5554cd516 100644
--- a/targets/tests/GridGeneratorTest/CMakeLists.txt
+++ b/targets/tests/GridGeneratorTest/CMakeLists.txt
@@ -2,7 +2,7 @@ setTargetNameToFolderName(${CMAKE_CURRENT_LIST_DIR})
set(linkDirectories "")
set(libsToLink GridGenerator)
-set(includeDirectories ${CMAKE_SOURCE_DIR}/src ${CMAKE_SOURCE_DIR}/src/GridGenerator)
+set(includeDirectories ${CMAKE_SOURCE_DIR}/src ${CMAKE_SOURCE_DIR}/src/GridGenerator "${CMAKE_SOURCE_DIR}/src/VirtualFluidsBasics")
#glob files and save in MY_SRCS
include(CMakePackage.cmake)
--
GitLab