diff --git a/apps/gpu/DiluteGravityCurrents_Case1/DiluteGravityCurrents_Case1.cpp b/apps/gpu/DiluteGravityCurrents_Case1/DiluteGravityCurrents_Case1.cpp
index 6473af944693e24440ce68137344d359f6c2e2df..838b2ccd5de9d89626ea8c61bf92592743a7ccba 100644
--- a/apps/gpu/DiluteGravityCurrents_Case1/DiluteGravityCurrents_Case1.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case1/DiluteGravityCurrents_Case1.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/DiluteGravityCurrents_Case2/DiluteGravityCurrents_Case2.cpp b/apps/gpu/DiluteGravityCurrents_Case2/DiluteGravityCurrents_Case2.cpp
index f0400a718ff17fe0fbb2f6edcea7997e9bf4f151..dcbb47c4b811434f10c6546e2c7b8ad2f829e6ae 100644
--- a/apps/gpu/DiluteGravityCurrents_Case2/DiluteGravityCurrents_Case2.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case2/DiluteGravityCurrents_Case2.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/DiluteGravityCurrents_Case3/DiluteGravityCurrents_Case3.cpp b/apps/gpu/DiluteGravityCurrents_Case3/DiluteGravityCurrents_Case3.cpp
index d452efdecabe07e730926d62efbd6af4f0bec555..e77d5f6ebc497bb8bd77a65cac6c6219c85ab5cc 100644
--- a/apps/gpu/DiluteGravityCurrents_Case3/DiluteGravityCurrents_Case3.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case3/DiluteGravityCurrents_Case3.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/DiluteGravityCurrents_Case4/DiluteGravityCurrents_Case4.cpp b/apps/gpu/DiluteGravityCurrents_Case4/DiluteGravityCurrents_Case4.cpp
index 96ea163ea10c201eeb7270bdc24f06317e29d129..7427aa9b7887e3645819a692f952f0e8320a81a1 100644
--- a/apps/gpu/DiluteGravityCurrents_Case4/DiluteGravityCurrents_Case4.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case4/DiluteGravityCurrents_Case4.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/DiluteGravityCurrents_Case5/DiluteGravityCurrents_Case5.cpp b/apps/gpu/DiluteGravityCurrents_Case5/DiluteGravityCurrents_Case5.cpp
index 849f1b35b3288c53f5c4925a2451dae083e0ef8d..9df9da2872112537b905fafc3f7275dfd6cb0430 100644
--- a/apps/gpu/DiluteGravityCurrents_Case5/DiluteGravityCurrents_Case5.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case5/DiluteGravityCurrents_Case5.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/DiluteGravityCurrents_Case6/DiluteGravityCurrents_Case6.cpp b/apps/gpu/DiluteGravityCurrents_Case6/DiluteGravityCurrents_Case6.cpp
index 751928fca4de3038e8532cc8c020a522492606ee..f1c8aa5c20d7bf987d0282c6e03b66a1ce3f89e2 100644
--- a/apps/gpu/DiluteGravityCurrents_Case6/DiluteGravityCurrents_Case6.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case6/DiluteGravityCurrents_Case6.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/DiluteGravityCurrents_Case7/DiluteGravityCurrents_Case7.cpp b/apps/gpu/DiluteGravityCurrents_Case7/DiluteGravityCurrents_Case7.cpp
index a6ac0ebb4a109889acbf6f7f4107a78c1e346c47..d6d4684369c03c90c63c02ae85ddfc2d5d88da89 100644
--- a/apps/gpu/DiluteGravityCurrents_Case7/DiluteGravityCurrents_Case7.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case7/DiluteGravityCurrents_Case7.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/DiluteGravityCurrents_Case8/DiluteGravityCurrents_Case8.cpp b/apps/gpu/DiluteGravityCurrents_Case8/DiluteGravityCurrents_Case8.cpp
index 94c0d76ef5ec2ffb0ac3c6cf2556913ed4b9db92..09459acd8ca78d37501c68ada334a98a6fc4a525 100644
--- a/apps/gpu/DiluteGravityCurrents_Case8/DiluteGravityCurrents_Case8.cpp
+++ b/apps/gpu/DiluteGravityCurrents_Case8/DiluteGravityCurrents_Case8.cpp
@@ -100,9 +100,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/apps/gpu/LidDrivenCavityGPU/LidDrivenCavity.cpp b/apps/gpu/LidDrivenCavityGPU/LidDrivenCavity.cpp
index 29da3199097ad39b5c3356ad6c29b5699fde61c2..a4fcec0f36e2c36b1fd90148b31a50fc998a8d26 100644
--- a/apps/gpu/LidDrivenCavityGPU/LidDrivenCavity.cpp
+++ b/apps/gpu/LidDrivenCavityGPU/LidDrivenCavity.cpp
@@ -123,9 +123,7 @@ int main(int argc, char *argv[])
// setup gridGenerator
//////////////////////////////////////////////////////////////////////////
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+ auto gridBuilder = MultipleGridBuilder::makeShared();
//////////////////////////////////////////////////////////////////////////
// create grid
diff --git a/src/gpu/GridGenerator/geometries/Object.cu b/src/gpu/GridGenerator/geometries/Object.cu
index f34aa19aab5961844087005da1402bd0485eb5e7..7a1fc8d8aedaed2d2390b2f36553e8ff4708efce 100644
--- a/src/gpu/GridGenerator/geometries/Object.cu
+++ b/src/gpu/GridGenerator/geometries/Object.cu
@@ -32,11 +32,10 @@
//=======================================================================================
#include "Object.h"
#include "grid/GridImp.h"
-#include "grid/GridStrategy/GridStrategy.h"
void Object::findInnerNodes(SPtr<GridImp> grid)
{
- grid->getGridStrategy()->findInnerNodes( grid );
+ grid->findInnerNodes();
}
int Object::getIntersection(const Vertex &P, const Vertex &direction, Vertex &pointOnObject, real &qVal)
diff --git a/src/gpu/GridGenerator/grid/Field.cu b/src/gpu/GridGenerator/grid/Field.cu
index 6e663751b9c9588388046010f24190a21df0ab9c..b330b2fba565287c1ddd21181d9e192f50fb5f82 100644
--- a/src/gpu/GridGenerator/grid/Field.cu
+++ b/src/gpu/GridGenerator/grid/Field.cu
@@ -33,33 +33,22 @@
#include "Field.h"
#include "grid/NodeValues.h"
-#include "grid/GridStrategy/GridStrategy.h"
using namespace vf::gpu;
-Field::Field(SPtr<GridStrategy> gridStrategy, uint size) : gridStrategy(gridStrategy), size(size)
-{
-
-}
-
-Field::Field()
-{
-
-}
-
-Field::~Field()
+Field::Field(uint size) : size(size)
{
}
void Field::allocateMemory()
{
- gridStrategy->allocateFieldMemory(this);
+ this->field = new char[this->size];
}
void Field::freeMemory()
{
- gridStrategy->freeFieldMemory(this);
+ delete[] this->field;
}
// --------------------------------------------------------- //
diff --git a/src/gpu/GridGenerator/grid/Field.h b/src/gpu/GridGenerator/grid/Field.h
index 9dc8e68578d69511afbd0ef7949d3a237249d70b..eafa81ec694b0b548efc1bbb510f5f18591ffbc3 100644
--- a/src/gpu/GridGenerator/grid/Field.h
+++ b/src/gpu/GridGenerator/grid/Field.h
@@ -36,14 +36,12 @@
#include "global.h"
struct Vertex;
-class GridStrategy;
class GRIDGENERATOR_EXPORT Field : public enableSharedFromThis<Field>
{
public:
- Field(SPtr<GridStrategy> gridStrategy, uint size);
- Field();
- ~Field();
+ Field(uint size);
+ Field() = default;
void allocateMemory();
void freeMemory();
@@ -74,13 +72,8 @@ public:
void setFieldEntryToInvalidOutOfGrid(uint index);
private:
- SPtr<GridStrategy> gridStrategy;
-
char *field;
uint size;
-
- friend class GridGpuStrategy;
- friend class GridCpuStrategy;
};
#endif
diff --git a/src/gpu/GridGenerator/grid/Grid.h b/src/gpu/GridGenerator/grid/Grid.h
index 1f8a33380bfcecdf1fc5d8fffc69a2bf40f9486c..3407b23c1efbb4143d06ded7880c26d7c0eb6599 100644
--- a/src/gpu/GridGenerator/grid/Grid.h
+++ b/src/gpu/GridGenerator/grid/Grid.h
@@ -44,7 +44,6 @@
class TriangularMesh;
struct Vertex;
struct Triangle;
-class GridStrategy;
class GridInterface;
class Object;
class BoundingBox;
@@ -52,7 +51,7 @@ class BoundingBox;
class GRIDGENERATOR_EXPORT Grid
{
public:
- virtual ~Grid() {}
+ virtual ~Grid() = default;
virtual const Object* getObject() const = 0;
@@ -104,7 +103,6 @@ public:
virtual void getNodeValues(real *xCoords, real *yCoords, real *zCoords, uint *neighborX, uint *neighborY, uint *neighborZ, uint *neighborNegative, uint *geo) const = 0;
- virtual SPtr<GridStrategy> getGridStrategy() const = 0;
virtual void transIndexToCoords(uint index, real &x, real &y, real &z) const = 0;
virtual uint transCoordToIndex(const real &x, const real &y, const real &z) const = 0;
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
index 2a5f017ad6aba501d1397a4a5b5569909860347a..6137256e99fc0f5edf3413d04b2908e127dd986f 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
@@ -45,8 +45,6 @@
#include "grid/Grid.h"
#include "grid/GridFactory.h"
#include "grid/GridInterface.h"
-#include "grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h"
-#include "grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h"
#include "grid/NodeValues.h"
#include "grid/partition/Partition.h"
@@ -64,7 +62,7 @@
using namespace vf::gpu;
-LevelGridBuilder::LevelGridBuilder(Device device, const std::string &d3qxx) : device(device), d3qxx(d3qxx)
+LevelGridBuilder::LevelGridBuilder()
{
this->communicationProcesses[CommunicationDirections::MX] = INVALID_INDEX;
this->communicationProcesses[CommunicationDirections::PX] = INVALID_INDEX;
@@ -74,9 +72,9 @@ LevelGridBuilder::LevelGridBuilder(Device device, const std::string &d3qxx) : de
this->communicationProcesses[CommunicationDirections::PZ] = INVALID_INDEX;
}
-std::shared_ptr<LevelGridBuilder> LevelGridBuilder::makeShared(Device device, const std::string& d3qxx)
+std::shared_ptr<LevelGridBuilder> LevelGridBuilder::makeShared()
{
- return SPtr<LevelGridBuilder>(new LevelGridBuilder(device, d3qxx));
+ return SPtr<LevelGridBuilder>(new LevelGridBuilder());
}
void LevelGridBuilder::setSlipBoundaryCondition(SideType sideType, real nomalX, real normalY, real normalZ)
@@ -184,15 +182,6 @@ GRIDGENERATOR_EXPORT uint LevelGridBuilder::getCommunicationProcess(int directio
return this->communicationProcesses[direction];
}
-void LevelGridBuilder::copyDataFromGpu()
-{
- for (const auto &grid : grids) {
- auto gridGpuStrategy = std::dynamic_pointer_cast<GridGpuStrategy>(grid->getGridStrategy());
- if (gridGpuStrategy)
- gridGpuStrategy->copyDataFromGPU(std::static_pointer_cast<GridImp>(grid));
- }
-}
-
LevelGridBuilder::~LevelGridBuilder()
{
for (const auto& grid : grids)
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
index c2f6b9da6f80f99d1ee36e1ee56af00c36505948..0e1e9e25f2883c4240744e224f3563f0e39191e4 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
+++ b/src/gpu/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
@@ -50,7 +50,6 @@ class Transformator;
class ArrowTransformator;
class PolyDataWriterWrapper;
class BoundingBox;
-enum class Device;
class Side;
class VelocityBoundaryCondition;
@@ -64,14 +63,13 @@ enum class SideType;
class LevelGridBuilder : public GridBuilder
{
protected:
- GRIDGENERATOR_EXPORT LevelGridBuilder(Device device, const std::string& d3qxx);
+ GRIDGENERATOR_EXPORT LevelGridBuilder();
public:
- GRIDGENERATOR_EXPORT static std::shared_ptr<LevelGridBuilder> makeShared(Device device, const std::string& d3qxx);
+ GRIDGENERATOR_EXPORT static std::shared_ptr<LevelGridBuilder> makeShared();
GRIDGENERATOR_EXPORT SPtr<Grid> getGrid(uint level) override;
- GRIDGENERATOR_EXPORT void copyDataFromGpu();
GRIDGENERATOR_EXPORT virtual ~LevelGridBuilder();
GRIDGENERATOR_EXPORT void setSlipBoundaryCondition(SideType sideType, real nomalX, real normalY, real normalZ);
@@ -156,10 +154,6 @@ protected:
Vertex getVertex(const int matrixIndex) const;
-private:
- Device device;
- std::string d3qxx;
-
public:
GRIDGENERATOR_EXPORT void getGridInformations(std::vector<int>& gridX, std::vector<int>& gridY,
std::vector<int>& gridZ, std::vector<int>& distX, std::vector<int>& distY,
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
index da01099cf8b33dce75f9cd612f85b1476a1fe504..47bea56435eeeebd1fba26b6e5aafb9cf1094a5b 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
@@ -49,15 +49,14 @@
#include "io/GridVTKWriter/GridVTKWriter.h"
#include "io/STLReaderWriter/STLWriter.h"
-MultipleGridBuilder::MultipleGridBuilder(SPtr<GridFactory> gridFactory, Device device, const std::string &d3qxx) :
- LevelGridBuilder(device, d3qxx), gridFactory(gridFactory), numberOfLayersFine(12), numberOfLayersBetweenLevels(8), subDomainBox(nullptr)
+MultipleGridBuilder::MultipleGridBuilder() : LevelGridBuilder(), numberOfLayersFine(12), numberOfLayersBetweenLevels(8), subDomainBox(nullptr)
{
}
-SPtr<MultipleGridBuilder> MultipleGridBuilder::makeShared(SPtr<GridFactory> gridFactory)
+SPtr<MultipleGridBuilder> MultipleGridBuilder::makeShared()
{
- return SPtr<MultipleGridBuilder>(new MultipleGridBuilder(gridFactory));
+ return SPtr<MultipleGridBuilder>(new MultipleGridBuilder());
}
void MultipleGridBuilder::addCoarseGrid(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta)
@@ -196,7 +195,7 @@ void MultipleGridBuilder::addGridToListIfValid(SPtr<Grid> grid)
SPtr<Grid> MultipleGridBuilder::makeGrid(Object* gridShape, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, uint level) const
{
- return gridFactory->makeGrid(gridShape, startX, startY, startZ, endX, endY, endZ, delta, level);
+ return GridImp::makeShared(gridShape, startX, startY, startZ, endX, endY, endZ, delta, "D3Q27", level);
}
bool MultipleGridBuilder::coarseGridExists() const
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
index 5f2f5435303921afdc54ea6a9ab3e5d78e202335..8c05a61ca142fbefb537ce2d9304d5bd523355ef 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
@@ -41,7 +41,7 @@
#include "global.h"
#include "grid/GridBuilder/LevelGridBuilder.h"
-#include "grid/GridFactory.h"
+#include "grid/distributions/Distribution.h"
class Object;
class BoundingBox;
@@ -49,10 +49,10 @@ class BoundingBox;
class MultipleGridBuilder : public LevelGridBuilder
{
private:
- GRIDGENERATOR_EXPORT MultipleGridBuilder(SPtr<GridFactory> gridFactory, Device device = Device::CPU, const std::string &d3qxx = "D3Q27");
+ GRIDGENERATOR_EXPORT MultipleGridBuilder();
public:
- GRIDGENERATOR_EXPORT static SPtr<MultipleGridBuilder> makeShared(SPtr<GridFactory> gridFactory);
+ GRIDGENERATOR_EXPORT static SPtr<MultipleGridBuilder> makeShared();
GRIDGENERATOR_EXPORT void addCoarseGrid(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta);
GRIDGENERATOR_EXPORT void addGrid(Object *gridShape);
@@ -103,7 +103,6 @@ private:
static void emitNoCoarseGridExistsWarning();
static void emitGridIsNotInCoarseGridWarning();
- SPtr<GridFactory> gridFactory;
Object *solidObject;
uint numberOfLayersFine;
diff --git a/src/gpu/GridGenerator/grid/GridFactory.cpp b/src/gpu/GridGenerator/grid/GridFactory.cpp
deleted file mode 100644
index 3e2297c2105908c50485d1556c7060c9a3e15b74..0000000000000000000000000000000000000000
--- a/src/gpu/GridGenerator/grid/GridFactory.cpp
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "GridFactory.h"
-
-
-
diff --git a/src/gpu/GridGenerator/grid/GridFactory.h b/src/gpu/GridGenerator/grid/GridFactory.h
index 9ebf1e3a13184a9b3aea75694c74e039fc987ad5..dd659cda323feb3918925329d1fac8b454ec9b45 100644
--- a/src/gpu/GridGenerator/grid/GridFactory.h
+++ b/src/gpu/GridGenerator/grid/GridFactory.h
@@ -37,15 +37,9 @@
#include "geometries/Cuboid/Cuboid.h"
-#include "grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h"
#include "grid/distributions/Distribution.h"
#include "grid/GridImp.h"
-enum class Device
-{
- CPU, GPU
-};
-
enum class TriangularMeshDiscretizationMethod
{
RAYCASTING, POINT_IN_OBJECT, POINT_UNDER_TRIANGLE
@@ -59,43 +53,12 @@ public:
return SPtr<GridFactory>(new GridFactory());
}
-private:
- GridFactory()
- {
- gridStrategy = SPtr<GridStrategy>(new GridCpuStrategy());
- }
-
-public:
SPtr<Grid> makeGrid(Object* gridShape, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, uint level, const std::string& d3Qxx = "D3Q27")
{
Distribution distribution = DistributionHelper::getDistribution(d3Qxx);
- SPtr<GridImp> grid;
-
- grid = GridImp::makeShared(gridShape, startX, startY, startZ, endX, endY, endZ, delta, gridStrategy, distribution, level);
-
- return grid;
+ return GridImp::makeShared(gridShape, startX, startY, startZ, endX, endY, endZ, delta, d3Qxx, level);
}
-
-
- void setGridStrategy(Device device)
- {
- switch (device)
- {
- case Device::CPU:
- gridStrategy = SPtr<GridStrategy>(new GridCpuStrategy()); break;
- case Device::GPU:
- throw std::runtime_error("GPU Device for GridGenerator not supported.");
- }
- }
-
- void setGridStrategy(SPtr<GridStrategy> gridStrategy)
- {
- this->gridStrategy = gridStrategy;
- }
-
-private:
- SPtr<GridStrategy> gridStrategy;
};
diff --git a/src/gpu/GridGenerator/grid/GridImp.cu b/src/gpu/GridGenerator/grid/GridImp.cu
index 27ab17b796de1a573f7d057ff6756e93a0e3a1e7..6bb3db8d4da57865e576a6dc8b3909c669bc64a3 100644
--- a/src/gpu/GridGenerator/grid/GridImp.cu
+++ b/src/gpu/GridGenerator/grid/GridImp.cu
@@ -47,7 +47,6 @@
#include "geometries/TriangularMesh/TriangularMeshStrategy.h"
#include "geometries/BoundingBox/BoundingBox.h"
-#include "grid/GridStrategy/GridStrategy.h"
#include "grid/distributions/Distribution.h"
#include "grid/Field.h"
#include "grid/GridInterface.h"
@@ -62,7 +61,7 @@ int DIRECTIONS[DIR_END_MAX][DIMENSION];
using namespace vf::gpu;
-GridImp::GridImp(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, SPtr<GridStrategy> gridStrategy, Distribution distribution, uint level)
+GridImp::GridImp(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, Distribution distribution, uint level)
: object(object),
startX(startX),
startY(startY),
@@ -71,7 +70,6 @@ GridImp::GridImp(Object* object, real startX, real startY, real startZ, real end
endY(endY),
endZ(endZ),
delta(delta),
- gridStrategy(gridStrategy),
distribution(distribution),
level(level),
periodicityX(false),
@@ -94,9 +92,10 @@ GridImp::GridImp(Object* object, real startX, real startY, real startZ, real end
initalNumberOfNodesAndSize();
}
-SPtr<GridImp> GridImp::makeShared(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, SPtr<GridStrategy> gridStrategy, Distribution d, uint level)
+SPtr<GridImp> GridImp::makeShared(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, std::string d3Qxx, uint level)
{
- SPtr<GridImp> grid(new GridImp(object, startX, startY, startZ, endX, endY, endZ, delta, gridStrategy, d, level));
+ Distribution distribution = DistributionHelper::getDistribution(d3Qxx);
+ SPtr<GridImp> grid(new GridImp(object, startX, startY, startZ, endX, endY, endZ, delta, distribution, level));
return grid;
}
@@ -118,12 +117,24 @@ void GridImp::initalNumberOfNodesAndSize()
void GridImp::inital(const SPtr<Grid> fineGrid, uint numberOfLayers)
{
- field = Field(gridStrategy, size);
+ field = Field(size);
field.allocateMemory();
- gridStrategy->allocateGridMemory(shared_from_this());
-
+
+ this->neighborIndexX = new int[this->size];
+ this->neighborIndexY = new int[this->size];
+ this->neighborIndexZ = new int[this->size];
+ this->neighborIndexNegative = new int[this->size];
+
+ this->sparseIndices = new int[this->size];
+
+ this->qIndices = new uint[this->size];
+ for (uint i = 0; i < this->size; i++)
+ this->qIndices[i] = INVALID_INDEX;
+
*logging::out << logging::Logger::INFO_INTERMEDIATE << "Start initalNodesToOutOfGrid()\n";
- gridStrategy->initalNodesToOutOfGrid(shared_from_this());
+#pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++)
+ this->initalNodeToOutOfGrid(index);
if( this->innerRegionFromFinerGrid ){
*logging::out << logging::Logger::INFO_INTERMEDIATE << "Start setInnerBasedOnFinerGrid()\n";
@@ -138,16 +149,42 @@ void GridImp::inital(const SPtr<Grid> fineGrid, uint numberOfLayers)
this->addOverlap();
*logging::out << logging::Logger::INFO_INTERMEDIATE << "Start fixOddCells()\n";
- gridStrategy->fixOddCells( shared_from_this() );
+#pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++)
+ this->fixOddCell(index);
if( enableFixRefinementIntoTheWall )
{
*logging::out << logging::Logger::INFO_INTERMEDIATE << "Start fixRefinementIntoWall()\n";
- gridStrategy->fixRefinementIntoWall(shared_from_this());
+#pragma omp parallel for
+ for (int xIdx = 0; xIdx < (int)this->nx; xIdx++) {
+ for (uint yIdx = 0; yIdx < this->ny; yIdx++) {
+ this->fixRefinementIntoWall(xIdx, yIdx, 0, 3);
+ this->fixRefinementIntoWall(xIdx, yIdx, this->nz - 1, -3);
+ }
+ }
+
+#pragma omp parallel for
+ for (int xIdx = 0; xIdx < (int)this->nx; xIdx++) {
+ for (uint zIdx = 0; zIdx < this->nz; zIdx++) {
+ this->fixRefinementIntoWall(xIdx, 0, zIdx, 2);
+ this->fixRefinementIntoWall(xIdx, this->ny - 1, zIdx, -2);
+ }
+ }
+
+#pragma omp parallel for
+ for (int yIdx = 0; yIdx < (int)this->ny; yIdx++) {
+ for (uint zIdx = 0; zIdx < this->nz; zIdx++) {
+ this->fixRefinementIntoWall(0, yIdx, zIdx, 1);
+ this->fixRefinementIntoWall(this->nx - 1, yIdx, zIdx, -1);
+ }
+ }
}
*logging::out << logging::Logger::INFO_INTERMEDIATE << "Start findEndOfGridStopperNodes()\n";
- gridStrategy->findEndOfGridStopperNodes(shared_from_this());
+#pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++)
+ this->findEndOfGridStopperNode(index);
*logging::out << logging::Logger::INFO_INTERMEDIATE
<< "Grid created: " << "from (" << this->startX << ", " << this->startY << ", " << this->startZ << ") to (" << this->endX << ", " << this->endY << ", " << this->endZ << ")\n"
@@ -167,17 +204,23 @@ void GridImp::initalNodeToOutOfGrid(uint index) {
void GridImp::freeMemory()
{
- gridStrategy->freeMemory(shared_from_this());
+ if( this->neighborIndexX != nullptr ) { delete[] this->neighborIndexX; this->neighborIndexX = nullptr; }
+ if( this->neighborIndexY != nullptr ) { delete[] this->neighborIndexY; this->neighborIndexY = nullptr; }
+ if( this->neighborIndexZ != nullptr ) { delete[] this->neighborIndexZ; this->neighborIndexZ = nullptr; }
+ if( this->neighborIndexNegative != nullptr ) { delete[] this->neighborIndexNegative; this->neighborIndexNegative = nullptr; }
+ if( this->sparseIndices != nullptr ) { delete[] this->sparseIndices; this->sparseIndices = nullptr; }
+ if( this->qIndices != nullptr ) { delete[] this->qIndices; this->qIndices = nullptr; }
+ if( this->qValues != nullptr ) { delete[] this->qValues; this->qValues = nullptr; }
+ if( this->qPatches != nullptr ) { delete[] this->qPatches; this->qPatches = nullptr; }
- gridStrategy->freeFieldMemory(&field);
+ field.freeMemory();
}
-GridImp::GridImp()
-{
-}
-
-GridImp::~GridImp()
+void GridImp::findInnerNodes()
{
+#pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++)
+ this->findInnerNode(index);
}
void GridImp::findInnerNode(uint index)
@@ -293,7 +336,13 @@ void GridImp::setInnerBasedOnFinerGrid(const SPtr<Grid> fineGrid)
void GridImp::addOverlap()
{
for( uint layer = 0; layer < this->numberOfLayers; layer++ ){
- this->gridStrategy->addOverlap( shared_from_this() );
+#pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++)
+ this->setOverlapTmp(index);
+
+#pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++)
+ this->setOverlapFluid(index);
}
}
@@ -805,9 +854,24 @@ void GridImp::setNumberOfLayers(uint numberOfLayers)
// Set Sparse Indices //
// --------------------------------------------------------- //
-void GridImp::findSparseIndices(SPtr<Grid> fineGrid)
+void GridImp::findSparseIndices(SPtr<Grid> finerGrid)
{
- this->gridStrategy->findSparseIndices(shared_from_this(), std::static_pointer_cast<GridImp>(fineGrid));
+ *logging::out << logging::Logger::INFO_INTERMEDIATE << "Find sparse indices...";
+ auto fineGrid = std::static_pointer_cast<GridImp>(finerGrid);
+
+ this->updateSparseIndices();
+
+#pragma omp parallel for
+ for (int index = 0; index < (int)this->getSize(); index++)
+ this->setNeighborIndices(index);
+
+ if (fineGrid) {
+ fineGrid->updateSparseIndices();
+ }
+
+ const uint newGridSize = this->getSparseSize();
+ *logging::out << logging::Logger::INFO_INTERMEDIATE << "... done. new size: " << newGridSize
+ << ", delete nodes:" << this->getSize() - newGridSize << "\n";
}
@@ -980,7 +1044,38 @@ int GridImp::getSparseIndex(const real &x, const real &y, const real &z) const
// --------------------------------------------------------- //
void GridImp::findGridInterface(SPtr<Grid> finerGrid, LbmOrGks lbmOrGks)
{
- gridStrategy->findGridInterface(shared_from_this(), std::static_pointer_cast<GridImp>(finerGrid), lbmOrGks);
+ auto fineGrid = std::static_pointer_cast<GridImp>(finerGrid);
+ const auto coarseLevel = this->getLevel();
+ const auto fineLevel = fineGrid->getLevel();
+
+ *logging::out << logging::Logger::INFO_INTERMEDIATE << "find interface level " << coarseLevel << " -> "
+ << fineLevel;
+
+ this->gridInterface = new GridInterface();
+ // TODO: this is stupid! concave refinements can easily have many more interface cells
+ const uint sizeCF = 10 * (fineGrid->nx * fineGrid->ny + fineGrid->ny * fineGrid->nz + fineGrid->nx * fineGrid->nz);
+ this->gridInterface->cf.coarse = new uint[sizeCF];
+ this->gridInterface->cf.fine = new uint[sizeCF];
+ this->gridInterface->cf.offset = new uint[sizeCF];
+ this->gridInterface->fc.coarse = new uint[sizeCF];
+ this->gridInterface->fc.fine = new uint[sizeCF];
+ this->gridInterface->fc.offset = new uint[sizeCF];
+
+ for (uint index = 0; index < this->getSize(); index++)
+ this->findGridInterfaceCF(index, *fineGrid, lbmOrGks);
+
+ for (uint index = 0; index < this->getSize(); index++)
+ this->findGridInterfaceFC(index, *fineGrid);
+
+ for (uint index = 0; index < this->getSize(); index++)
+ this->findOverlapStopper(index, *fineGrid);
+
+ if (lbmOrGks == GKS) {
+ for (uint index = 0; index < this->getSize(); index++)
+ this->findInvalidBoundaryNodes(index);
+ }
+
+ *logging::out << logging::Logger::INFO_INTERMEDIATE << " ... done. \n";
}
void GridImp::repairGridInterfaceOnMultiGPU(SPtr<Grid> fineGrid)
@@ -1027,8 +1122,6 @@ void GridImp::limitToSubDomain(SPtr<BoundingBox> subDomainBox, LbmOrGks lbmOrGks
this->setFieldEntry(index, INVALID_OUT_OF_GRID);
}
}
-
- //this->gridStrategy->findEndOfGridStopperNodes(shared_from_this());
}
void GridImp::findGridInterfaceCF(uint index, GridImp& finerGrid, LbmOrGks lbmOrGks)
@@ -1066,14 +1159,19 @@ void GridImp::mesh(Object* object)
if (triangularMesh)
triangularMeshDiscretizationStrategy->discretize(triangularMesh, this, INVALID_SOLID, FLUID);
else
- //gridStrategy->findInnerNodes(shared_from_this()); //TODO: adds INNERTYPE AND OUTERTYPE to findInnerNodes
//new method for geometric primitives (not cell based) to be implemented
this->discretize(object, INVALID_SOLID, FLUID);
this->closeNeedleCells();
- gridStrategy->findSolidStopperNodes(shared_from_this());
- gridStrategy->findBoundarySolidNodes(shared_from_this());
+ #pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++)
+ this->findSolidStopperNode(index);
+
+ //#pragma omp parallel for
+ for (int index = 0; index < (int)this->size; index++) {
+ this->findBoundarySolidNode(index);
+ }
}
@@ -1081,7 +1179,9 @@ void GridImp::mesh(TriangularMesh &triangularMesh)
{
const clock_t begin = clock();
- gridStrategy->mesh(shared_from_this(), triangularMesh);
+#pragma omp parallel for
+ for (int i = 0; i < triangularMesh.size; i++)
+ this->mesh(triangularMesh.triangles[i]);
const clock_t end = clock();
const real time = (real)(real(end - begin) / CLOCKS_PER_SEC);
@@ -1122,7 +1222,12 @@ void GridImp::closeNeedleCells()
uint numberOfClosedNeedleCells = 0;
do{
- numberOfClosedNeedleCells = this->gridStrategy->closeNeedleCells( shared_from_this() );
+#pragma omp parallel for reduction(+ : numberOfClosedNeedleCells)
+ for (int index = 0; index < (int)this->size; index++) {
+ if (this->closeCellIfNeedle(index))
+ numberOfClosedNeedleCells++;
+ }
+
*logging::out << logging::Logger::INFO_INTERMEDIATE << numberOfClosedNeedleCells << " cells closed!\n";
}
while( numberOfClosedNeedleCells > 0 );
@@ -1157,7 +1262,12 @@ void GridImp::closeNeedleCellsThinWall()
uint numberOfClosedNeedleCells = 0;
do{
- numberOfClosedNeedleCells = this->gridStrategy->closeNeedleCellsThinWall( shared_from_this() );
+#pragma omp parallel for reduction(+ : numberOfClosedNeedleCells)
+ for (int index = 0; index < (int)this->size; index++) {
+ if (this->closeCellIfNeedleThinWall(index))
+ numberOfClosedNeedleCells++;
+ }
+
*logging::out << logging::Logger::INFO_INTERMEDIATE << numberOfClosedNeedleCells << " cells closed!\n";
}
while( numberOfClosedNeedleCells > 0 );
@@ -1189,15 +1299,31 @@ void GridImp::findQs(Object* object) //TODO: enable qs for primitive objects
findQsPrimitive(object);
}
+void GridImp::allocateQs()
+{
+ this->qPatches = new uint[this->getNumberOfSolidBoundaryNodes()];
+
+ for (uint i = 0; i < this->getNumberOfSolidBoundaryNodes(); i++)
+ this->qPatches[i] = INVALID_INDEX;
+
+ const uint numberOfQs = this->getNumberOfSolidBoundaryNodes() * (this->distribution.dir_end + 1);
+ this->qValues = new real[numberOfQs];
+#pragma omp parallel for
+ for (int i = 0; i < (int)numberOfQs; i++)
+ this->qValues[i] = -1.0;
+}
+
void GridImp::findQs(TriangularMesh &triangularMesh)
{
const clock_t begin = clock();
- if( this->qComputationStage == qComputationStageType::ComputeQs ){
- gridStrategy->allocateQs(shared_from_this());
- }
-
- gridStrategy->findQs(shared_from_this(), triangularMesh);
+ if( this->qComputationStage == qComputationStageType::ComputeQs )
+ allocateQs();
+
+
+#pragma omp parallel for
+ for (int i = 0; i < triangularMesh.size; i++)
+ this->findQs(triangularMesh.triangles[i]);
const clock_t end = clock();
const real time = (real)(real(end - begin) / CLOCKS_PER_SEC);
@@ -1251,9 +1377,8 @@ void GridImp::findQs(Triangle &triangle)
void GridImp::findQsPrimitive(Object * object)
{
- if( this->qComputationStage == qComputationStageType::ComputeQs ){
- gridStrategy->allocateQs(shared_from_this());
- }
+ if( this->qComputationStage == qComputationStageType::ComputeQs )
+ allocateQs();
for( int index = 0; index < (int)this->size; index++ )
@@ -1724,11 +1849,6 @@ uint GridImp::getNumberOfNodesZ() const
return nz;
}
-SPtr<GridStrategy> GridImp::getGridStrategy() const
-{
- return gridStrategy;
-}
-
int* GridImp::getNeighborsX() const
{
diff --git a/src/gpu/GridGenerator/grid/GridImp.h b/src/gpu/GridGenerator/grid/GridImp.h
index 938fa1d80914b0e2563da43ea62074d256ced79d..7d44b0bb58168a6bf4da87ad94cf5a8f533002ed 100644
--- a/src/gpu/GridGenerator/grid/GridImp.h
+++ b/src/gpu/GridGenerator/grid/GridImp.h
@@ -47,7 +47,6 @@
class TriangularMesh;
struct Vertex;
struct Triangle;
-class GridStrategy;
class GridInterface;
class Object;
class BoundingBox;
@@ -72,12 +71,11 @@ extern int DIRECTIONS[DIR_END_MAX][DIMENSION];
class GRIDGENERATOR_EXPORT GridImp : public enableSharedFromThis<GridImp>, public Grid
{
private:
- GridImp();
- GridImp(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, SPtr<GridStrategy> gridStrategy, Distribution d, uint level);
+ GridImp() = default;
+ GridImp(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, Distribution d, uint level);
public:
- virtual ~GridImp();
- static SPtr<GridImp> makeShared(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, SPtr<GridStrategy> gridStrategy, Distribution d, uint level);
+ static SPtr<GridImp> makeShared(Object* object, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, std::string d3Qxx, uint level);
private:
void initalNumberOfNodesAndSize();
@@ -126,7 +124,6 @@ private:
uint numberOfLayers;
- SPtr<GridStrategy> gridStrategy;
TriangularMeshDiscretizationStrategy *triangularMeshDiscretizationStrategy;
uint numberOfSolidBoundaryNodes;
@@ -184,6 +181,7 @@ public:
void initalNodeToOutOfGrid(uint index);
+ void findInnerNodes();
void findInnerNode(uint index);
void discretize(Object *object, char innerType, char outerType);
@@ -263,8 +261,6 @@ public:
uint *getFC_fine() const override;
uint *getFC_offset() const override;
- SPtr<GridStrategy> getGridStrategy() const override;
-
void print() const;
public:
@@ -327,6 +323,8 @@ private:
bool checkIfAtLeastOneValidQ(const uint index, const Vertex &point, Object *object) const;
+ void allocateQs();
+
public:
void findCommunicationIndices(int direction, SPtr<BoundingBox> subDomainBox, LbmOrGks lbmOrGks) override;
void findCommunicationIndex(uint index, real coordinate, real limit, int direction);
@@ -347,9 +345,6 @@ public:
std::array<CommunicationIndices, 6> communicationIndices;
-private:
- friend class GridGpuStrategy;
- friend class GridCpuStrategy;
};
#endif
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp b/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
deleted file mode 100644
index 79f89b5a185de4edc961a0dd968dbac38ab065c0..0000000000000000000000000000000000000000
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
+++ /dev/null
@@ -1,298 +0,0 @@
-//=======================================================================================
-// ____ ____ __ ______ __________ __ __ __ __
-// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
-// \ \ | | | | | |_) | | | | | | | / \ | |
-// \ \ | | | | | _ / | | | | | | / /\ \ | |
-// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
-// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
-// \ \ | | ________________________________________________________________
-// \ \ | | | ______________________________________________________________|
-// \ \| | | | __ __ __ __ ______ _______
-// \ | | |_____ | | | | | | | | | _ \ / _____)
-// \ | | _____| | | | | | | | | | | \ \ \_______
-// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
-// \ _____| |__| |________| \_______/ |__| |______/ (_______/
-//
-// This file is part of VirtualFluids. VirtualFluids is free software: you can
-// redistribute it and/or modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation, either version 3 of
-// the License, or (at your option) any later version.
-//
-// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
-// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-// for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
-//
-//! \file GridCpuStrategy.cpp
-//! \ingroup grid
-//! \author Soeren Peters, Stephan Lenz
-//=======================================================================================
-#include "GridCpuStrategy.h"
-
-#include <time.h>
-#include <stdio.h>
-#include <omp.h>
-#include <vector>
-#include <iostream>
-
-#include "geometries/TriangularMesh/TriangularMesh.h"
-
-#include "grid/GridImp.h"
-#include "grid/GridInterface.h"
-#include "grid/NodeValues.h"
-#include "grid/distributions/Distribution.h"
-
-using namespace vf::gpu;
-
-void GridCpuStrategy::allocateGridMemory(SPtr<GridImp> grid)
-{
- grid->neighborIndexX = new int[grid->size];
- grid->neighborIndexY = new int[grid->size];
- grid->neighborIndexZ = new int[grid->size];
- grid->neighborIndexNegative = new int[grid->size];
-
- grid->sparseIndices = new int[grid->size];
-
- grid->qIndices = new uint[grid->size];
- for (uint i = 0; i < grid->size; i++)
- grid->qIndices[i] = INVALID_INDEX;
-}
-
-void GridCpuStrategy::allocateQs(SPtr<GridImp> grid)
-{
- grid->qPatches = new uint[grid->getNumberOfSolidBoundaryNodes()];
-
- for (uint i = 0; i < grid->getNumberOfSolidBoundaryNodes(); i++)
- grid->qPatches[i] = INVALID_INDEX;
-
- const uint numberOfQs = grid->getNumberOfSolidBoundaryNodes() * (grid->distribution.dir_end + 1);
- grid->qValues = new real[numberOfQs];
-#pragma omp parallel for
- for (int i = 0; i < (int)numberOfQs; i++)
- grid->qValues[i] = -1.0;
-}
-
-void GridCpuStrategy::initalNodesToOutOfGrid(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->initalNodeToOutOfGrid(index);
-}
-
-void GridCpuStrategy::allocateFieldMemory(Field* field)
-{
- field->field = new char[field->size];
-}
-
-
-void GridCpuStrategy::findInnerNodes(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->findInnerNode(index);
-}
-
-void GridCpuStrategy::addOverlap(SPtr<GridImp> grid)
-{
-
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->setOverlapTmp(index);
-
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->setOverlapFluid(index);
-}
-
-void GridCpuStrategy::fixOddCells(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->fixOddCell(index);
-}
-
-void GridCpuStrategy::fixRefinementIntoWall(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int xIdx = 0; xIdx < (int)grid->nx; xIdx++) {
- for (uint yIdx = 0; yIdx < grid->ny; yIdx++) {
- grid->fixRefinementIntoWall(xIdx, yIdx, 0, 3);
- grid->fixRefinementIntoWall(xIdx, yIdx, grid->nz - 1, -3);
- }
- }
-
-#pragma omp parallel for
- for (int xIdx = 0; xIdx < (int)grid->nx; xIdx++) {
- for (uint zIdx = 0; zIdx < grid->nz; zIdx++) {
- grid->fixRefinementIntoWall(xIdx, 0, zIdx, 2);
- grid->fixRefinementIntoWall(xIdx, grid->ny - 1, zIdx, -2);
- }
- }
-
-#pragma omp parallel for
- for (int yIdx = 0; yIdx < (int)grid->ny; yIdx++) {
- for (uint zIdx = 0; zIdx < grid->nz; zIdx++) {
- grid->fixRefinementIntoWall(0, yIdx, zIdx, 1);
- grid->fixRefinementIntoWall(grid->nx - 1, yIdx, zIdx, -1);
- }
- }
-}
-
-void GridCpuStrategy::findStopperNodes(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->findStopperNode(index);
-}
-
-void GridCpuStrategy::findEndOfGridStopperNodes(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->findEndOfGridStopperNode(index);
-}
-
-void GridCpuStrategy::findSolidStopperNodes(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++)
- grid->findSolidStopperNode(index);
-}
-
-void GridCpuStrategy::findBoundarySolidNodes(SPtr<GridImp> grid)
-{
- //#pragma omp parallel for
- for (int index = 0; index < (int)grid->size; index++) {
- grid->findBoundarySolidNode(index);
- }
-}
-
-void GridCpuStrategy::mesh(SPtr<GridImp> grid, TriangularMesh &geom)
-{
-#pragma omp parallel for
- for (int i = 0; i < geom.size; i++)
- grid->mesh(geom.triangles[i]);
-}
-
-uint GridCpuStrategy::closeNeedleCells(SPtr<GridImp> grid)
-{
- uint numberOfClosedNeedleCells = 0;
-
-#pragma omp parallel for reduction(+ : numberOfClosedNeedleCells)
- for (int index = 0; index < (int)grid->size; index++) {
- if (grid->closeCellIfNeedle(index))
- numberOfClosedNeedleCells++;
- }
-
- return numberOfClosedNeedleCells;
-}
-
-uint GridCpuStrategy::closeNeedleCellsThinWall(SPtr<GridImp> grid)
-{
- uint numberOfClosedNeedleCells = 0;
-
-#pragma omp parallel for reduction(+ : numberOfClosedNeedleCells)
- for (int index = 0; index < (int)grid->size; index++) {
- if (grid->closeCellIfNeedleThinWall(index))
- numberOfClosedNeedleCells++;
- }
-
- return numberOfClosedNeedleCells;
-}
-
-void GridCpuStrategy::findQs(SPtr<GridImp> grid, TriangularMesh &geom)
-{
-#pragma omp parallel for
- for (int i = 0; i < geom.size; i++)
- grid->findQs(geom.triangles[i]);
-}
-
-void GridCpuStrategy::findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid, LbmOrGks lbmOrGks)
-{
- const auto coarseLevel = grid->getLevel();
- const auto fineLevel = fineGrid->getLevel();
-
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "find interface level " << coarseLevel << " -> "
- << fineLevel;
-
- grid->gridInterface = new GridInterface();
- // TODO: this is stupid! concave refinements can easily have many more interface cells
- const uint sizeCF = 10 * (fineGrid->nx * fineGrid->ny + fineGrid->ny * fineGrid->nz + fineGrid->nx * fineGrid->nz);
- grid->gridInterface->cf.coarse = new uint[sizeCF];
- grid->gridInterface->cf.fine = new uint[sizeCF];
- grid->gridInterface->cf.offset = new uint[sizeCF];
- grid->gridInterface->fc.coarse = new uint[sizeCF];
- grid->gridInterface->fc.fine = new uint[sizeCF];
- grid->gridInterface->fc.offset = new uint[sizeCF];
-
- for (uint index = 0; index < grid->getSize(); index++)
- grid->findGridInterfaceCF(index, *fineGrid, lbmOrGks);
-
- for (uint index = 0; index < grid->getSize(); index++)
- grid->findGridInterfaceFC(index, *fineGrid);
-
- for (uint index = 0; index < grid->getSize(); index++)
- grid->findOverlapStopper(index, *fineGrid);
-
- if (lbmOrGks == GKS) {
- for (uint index = 0; index < grid->getSize(); index++)
- grid->findInvalidBoundaryNodes(index);
- }
-
- *logging::out << logging::Logger::INFO_INTERMEDIATE << " ... done. \n";
-}
-
-void GridCpuStrategy::findSparseIndices(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid)
-{
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "Find sparse indices...";
-
- coarseGrid->updateSparseIndices();
- findForNeighborsNewIndices(coarseGrid);
- if (fineGrid)
- {
- fineGrid->updateSparseIndices();
- }
-
- const uint newGridSize = coarseGrid->getSparseSize();
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "... done. new size: " << newGridSize << ", delete nodes:" << coarseGrid->getSize() - newGridSize << "\n";
-}
-
-
-void GridCpuStrategy::findForNeighborsNewIndices(SPtr<GridImp> grid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->getSize(); index++)
- grid->setNeighborIndices(index);
-}
-
-void GridCpuStrategy::findForGridInterfaceNewIndices(SPtr<GridImp> grid, SPtr<GridImp> fineGrid)
-{
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->getNumberOfNodesCF(); index++)
- grid->gridInterface->findForGridInterfaceSparseIndexCF(grid.get(), fineGrid.get(), index);
-
-#pragma omp parallel for
- for (int index = 0; index < (int)grid->getNumberOfNodesFC(); index++)
- grid->gridInterface->findForGridInterfaceSparseIndexFC(grid.get(), fineGrid.get(), index);
-}
-
-void GridCpuStrategy::freeFieldMemory(Field* field)
-{
- delete[] field->field;
-}
-
-void GridCpuStrategy::freeMemory(SPtr<GridImp> grid)
-{
- if( grid->neighborIndexX != nullptr ) { delete[] grid->neighborIndexX; grid->neighborIndexX = nullptr; }
- if( grid->neighborIndexY != nullptr ) { delete[] grid->neighborIndexY; grid->neighborIndexY = nullptr; }
- if( grid->neighborIndexZ != nullptr ) { delete[] grid->neighborIndexZ; grid->neighborIndexZ = nullptr; }
- if( grid->neighborIndexNegative != nullptr ) { delete[] grid->neighborIndexNegative; grid->neighborIndexNegative = nullptr; }
- if( grid->sparseIndices != nullptr ) { delete[] grid->sparseIndices; grid->sparseIndices = nullptr; }
- if( grid->qIndices != nullptr ) { delete[] grid->qIndices; grid->qIndices = nullptr; }
- if( grid->qValues != nullptr ) { delete[] grid->qValues; grid->qValues = nullptr; }
- if( grid->qPatches != nullptr ) { delete[] grid->qPatches; grid->qPatches = nullptr; }
-}
-
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h b/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
deleted file mode 100644
index c5c52d68a86e4ca95f928ff737a0e91aa5b4e1ee..0000000000000000000000000000000000000000
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
+++ /dev/null
@@ -1,85 +0,0 @@
-//=======================================================================================
-// ____ ____ __ ______ __________ __ __ __ __
-// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
-// \ \ | | | | | |_) | | | | | | | / \ | |
-// \ \ | | | | | _ / | | | | | | / /\ \ | |
-// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
-// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
-// \ \ | | ________________________________________________________________
-// \ \ | | | ______________________________________________________________|
-// \ \| | | | __ __ __ __ ______ _______
-// \ | | |_____ | | | | | | | | | _ \ / _____)
-// \ | | _____| | | | | | | | | | | \ \ \_______
-// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
-// \ _____| |__| |________| \_______/ |__| |______/ (_______/
-//
-// This file is part of VirtualFluids. VirtualFluids is free software: you can
-// redistribute it and/or modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation, either version 3 of
-// the License, or (at your option) any later version.
-//
-// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
-// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-// for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
-//
-//! \file GridCpuStrategy.h
-//! \ingroup grid
-//! \author Soeren Peters, Stephan Lenz
-//=======================================================================================
-#ifndef GRID_CPU_STRATEGY_H
-#define GRID_CPU_STRATEGY_H
-
-#include "global.h"
-
-#include "grid/GridStrategy/GridStrategy.h"
-
-class GridImp;
-class TriangularMesh;
-
-class GRIDGENERATOR_EXPORT GridCpuStrategy : public GridStrategy
-{
-public:
- virtual ~GridCpuStrategy(){};
-
- void allocateGridMemory(SPtr<GridImp> grid) override;
-
- void allocateQs(SPtr<GridImp> grid) override;
-
- void initalNodesToOutOfGrid(SPtr<GridImp> grid) override;
- void fixOddCells(SPtr<GridImp> grid) override;
- void findInnerNodes(SPtr<GridImp> grid) override;
- void addOverlap(SPtr<GridImp> grid) override;
- void fixRefinementIntoWall(SPtr<GridImp> grid) override;
- void findStopperNodes(SPtr<GridImp> grid) override;
- void findBoundarySolidNodes(SPtr<GridImp> grid) override;
- void findEndOfGridStopperNodes(SPtr<GridImp> grid) override;
- void findSolidStopperNodes(SPtr<GridImp> grid) override;
-
- void mesh(SPtr<GridImp> grid, TriangularMesh &geom) override;
-
- uint closeNeedleCells(SPtr<GridImp> grid) override;
- uint closeNeedleCellsThinWall(SPtr<GridImp> grid) override;
-
- void findQs(SPtr<GridImp> grid, TriangularMesh &geom) override;
-
- void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid, LbmOrGks lbmOrGks) override;
-
- void freeMemory(SPtr<GridImp> grid) override;
-
- virtual void copyDataFromGPU(){};
-
-protected:
- static void findForNeighborsNewIndices(SPtr<GridImp> grid);
- static void findForGridInterfaceNewIndices(SPtr<GridImp> grid, SPtr<GridImp> fineGrid);
-
-public:
- void allocateFieldMemory(Field *field) override;
- void freeFieldMemory(Field *field) override;
- void findSparseIndices(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid) override;
-};
-
-#endif
\ No newline at end of file
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp b/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
deleted file mode 100644
index a19daf22aba77480763c7c91f6bf29bb6ebacdd3..0000000000000000000000000000000000000000
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
+++ /dev/null
@@ -1,430 +0,0 @@
-#include "GridGpuStrategy.h"
-
-#include "Core/Timer/Timer.h"
-
-#include "geometries/BoundingBox/BoundingBox.h"
-#include "geometries/TriangularMesh/TriangularMesh.h"
-
-#include "grid/kernel/runGridKernelGPU.cuh"
-#include "grid/distributions/Distribution.h"
-#include "grid/GridImp.h"
-#include "grid/GridInterface.h"
-
-#include "utilities/cuda/CudaErrorCheck.cu"
-#include "utilities/cuda/LaunchParameter.cuh"
-
-void GridGpuStrategy::allocateGridMemory(SPtr<GridImp> grid)
-{
- //printCudaInformation(0);
- cudaSetDevice(0);
-
- this->allocDistribution(grid);
- this->allocField(grid);
- this->allocMatrixIndicesOnGPU(grid);
- this->allocNeighborsIndices(grid);
-}
-
-void GridGpuStrategy::allocateQs(SPtr<GridImp> grid)
-{
-}
-
-void GridGpuStrategy::initalNodesToOutOfGrid(SPtr<GridImp> grid)
-{
-
-}
-
-void GridGpuStrategy::fixOddCells(SPtr<GridImp> grid)
-{
-}
-
-
-
-void GridGpuStrategy::findInnerNodes(SPtr<GridImp> grid)
-{
- //float time = runKernelInitalUniformGrid3d(LaunchParameter::make_2D1D_launchParameter(grid->size, 256), *grid.get());
-}
-
-void GridGpuStrategy::addOverlap(SPtr<GridImp> grid)
-{
-}
-
-void GridGpuStrategy::fixRefinementIntoWall(SPtr<GridImp> grid)
-{
-}
-
-void GridGpuStrategy::findStopperNodes(SPtr<GridImp> grid)
-{
-
-}
-
-void GridGpuStrategy::findBoundarySolidNodes(SPtr<GridImp> grid)
-{
-}
-
-void GridGpuStrategy::findEndOfGridStopperNodes(SPtr<GridImp> grid)
-{
-
-}
-
-void GridGpuStrategy::findSolidStopperNodes(SPtr<GridImp> grid)
-{
-
-}
-
-void GridGpuStrategy::mesh(SPtr<GridImp> grid, TriangularMesh &geom)
-{
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "start meshing on GPU...\n";
- allocAndCopyTrianglesToGPU(geom);
-
- /*---------------------------------------------------------------------------------*/
- float time = runKernelToMesh(LaunchParameter::make_1D1D_launchParameter(geom.size, 256), *grid.get(), geom);
- /*---------------------------------------------------------------------------------*/
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "Time GPU build grid: " << time / 1000 << "sec\n";
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "-------------------------------------------\n";
-
- freeTrianglesFromGPU(geom);
-
-}
-
-uint GridGpuStrategy::closeNeedleCells(SPtr<GridImp> grid)
-{
- return uint();
-}
-
-uint GridGpuStrategy::closeNeedleCellsThinWall(SPtr<GridImp> grid)
-{
- return uint();
-}
-
-
-void GridGpuStrategy::findQs(SPtr<GridImp> grid, TriangularMesh &geom)
-{
-
-}
-
-
-void GridGpuStrategy::findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid, LbmOrGks lbmOrGks)
-{
- //copyAndFreeFieldFromGPU(grid->getField());
- //copyAndFreeFieldFromGPU(fineGrid->getField());
- //copyAndFreeMatrixIndicesFromGPU(grid, grid->size);
- //copyAndFreeMatrixIndicesFromGPU(fineGrid, fineGrid->getSize());
-
- //grid->gridInterface = new GridInterface();
- //const uint sizeCF = fineGrid->nx * fineGrid->ny + fineGrid->ny * fineGrid->nz + fineGrid->nx * fineGrid->nz;
- //grid->gridInterface->cf.coarse = new uint[sizeCF];
- //grid->gridInterface->cf.fine = new uint[sizeCF];
- //grid->gridInterface->fc.coarse = new uint[sizeCF];
- //grid->gridInterface->fc.fine = new uint[sizeCF];
-
- ////for (uint index = 0; index < grid->getSize(); index++)
- //// grid->findGridInterface(index, *fineGrid.get());
-
- //uint *cfc;
- //uint *cff;
- //uint *fcc;
- //uint *fcf;
-
- //CudaSafeCall(cudaMalloc(&cfc, sizeCF * sizeof(uint)));
- //CudaSafeCall(cudaMalloc(&cff, sizeCF * sizeof(uint)));
- //CudaSafeCall(cudaMalloc(&fcc, sizeCF * sizeof(uint)));
- //CudaSafeCall(cudaMalloc(&fcf, sizeCF * sizeof(uint)));
-
- //CudaSafeCall(cudaMemcpy(cfc, grid->gridInterface->cf.coarse, grid->gridInterface->cf.numberOfEntries * sizeof(uint), cudaMemcpyHostToDevice));
- //CudaSafeCall(cudaMemcpy(cff, grid->gridInterface->cf.fine, grid->gridInterface->cf.numberOfEntries * sizeof(uint), cudaMemcpyHostToDevice));
- //CudaSafeCall(cudaMemcpy(fcc, grid->gridInterface->fc.coarse, grid->gridInterface->fc.numberOfEntries * sizeof(uint), cudaMemcpyHostToDevice));
- //CudaSafeCall(cudaMemcpy(fcf, grid->gridInterface->fc.fine, grid->gridInterface->fc.numberOfEntries * sizeof(uint), cudaMemcpyHostToDevice));
-
- //grid->gridInterface->cf.coarse = cfc;
- //grid->gridInterface->cf.fine = cff;
- //grid->gridInterface->fc.coarse = fcc;
- //grid->gridInterface->fc.fine = fcf;
-
- //GridInterface *gridInterface_d;
- //CudaSafeCall(cudaMalloc(&gridInterface_d, sizeof(GridInterface)));
- //CudaSafeCall(cudaMemcpy(gridInterface_d, grid->gridInterface, sizeof(GridInterface), cudaMemcpyHostToDevice));
- //grid->gridInterface = gridInterface_d;
- //CudaCheckError();
-
-
- //grid->updateSparseIndices();
-
- //allocAndCopyFieldToGPU(grid->getField());
- //allocAndCopyFieldToGPU(fineGrid->getField());
- //allocAndCopyMatrixIndicesToGPU(grid, grid->size);
- //allocAndCopyMatrixIndicesToGPU(fineGrid, fineGrid->size);
-
- //float time = runKernelToFindNeighborsNewIndices(LaunchParameter::make_2D1D_launchParameter(grid->size, 256), *grid.get());
- //float time2 = runKernelToFindGridInterfaceNewIndices(LaunchParameter::make_2D1D_launchParameter(grid->size, 256), *grid.get());
-
- //copyAndFreeGridInterfaceFromGPU(grid);
-
-
- ////*logging::out << logging::Logger::INTERMEDIATE << "time find indices: " << time / 1000 << "sec\n";
-}
-
-//void GridGpuStrategy::deleteSolidNodes(SPtr<GridImp> grid)
-//{
-// float time1 = runKernelSetToInvalid(LaunchParameter::make_2D1D_launchParameter(grid->size, 512), *grid.get());
-//
-// copyAndFreeFieldFromGPU(grid->getField());
-// copyAndFreeMatrixIndicesFromGPU(grid, grid->size);
-//
-// grid->updateSparseIndices();
-//
-// allocAndCopyFieldToGPU(grid->getField());
-// allocAndCopyMatrixIndicesToGPU(grid, grid->size);
-//
-// float time2 = runKernelFindIndices(LaunchParameter::make_2D1D_launchParameter(grid->size, 256), *grid.get());
-// *logging::out << logging::Logger::INFO_INTERMEDIATE << "time delete solid nodes: " << (time1 + time2) / 1000 << "sec\n";
-//}
-
-
-
-void GridGpuStrategy::freeMemory(SPtr<GridImp> grid)
-{
- //delete[] grid->gridInterface->cf.coarse;
- //delete[] grid->gridInterface->cf.fine;
-
- //delete[] grid->gridInterface->fc.coarse;
- //delete[] grid->gridInterface->fc.fine;
-
- //delete grid->gridInterface;
-
- delete[] grid->neighborIndexX;
- delete[] grid->neighborIndexY;
- delete[] grid->neighborIndexZ;
- delete[] grid->neighborIndexNegative;
- delete[] grid->sparseIndices;
-
- delete[] grid->distribution.f;
-}
-
-
-
-void GridGpuStrategy::copyDataFromGPU(SPtr<GridImp> grid)
-{
- //copyAndFreeFieldFromGPU(grid->getField());
- //copyAndFreeNeighborsToCPU(grid);
- //copyAndFreeMatrixIndicesFromGPU(grid, grid->size);
- //copyAndFreeDistributiondFromGPU(grid);
-}
-
-void GridGpuStrategy::allocField(SPtr<GridImp> grid)
-{
- //int size_in_bytes = grid->size * sizeof(char);
- //CudaSafeCall(cudaMalloc(grid->getField().field, size_in_bytes));
-}
-
-
-void GridGpuStrategy::allocateFieldMemory(Field* field)
-{
- long size = field->size * sizeof(char) / 1000 / 1000;
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "alloc on device for grid field: " << int(size) << " MB\n";
-
- char *field_d;
- CudaSafeCall(cudaMalloc(&field_d, field->size * sizeof(char)));
- field->field = field_d;
-}
-
-void GridGpuStrategy::freeFieldMemory(Field* field)
-{
-}
-
-void GridGpuStrategy::findSparseIndices(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid)
-{
-}
-
-//
-//void GridWrapperGPU::markNodesToDeleteOutsideOfGeometry()
-//{
-// int numberOfEdgeNodes = grid.ny * grid.nz;
-//
-// /*---------------------------------------------------------------------------------*/
-// float time = runKernelToMarkNodesToDeleteOutsideOfGeometry(LaunchParameter::make_1D1D_launchParameter(numberOfEdgeNodes, 256), grid);
-// /*---------------------------------------------------------------------------------*/
-//
-// *logging::out << logging::Logger::INTERMEDIATE << "mark nodes to delete: " << time / 1000 << "sec\n";
-// *logging::out << logging::Logger::INTERMEDIATE << "-------------------------------------------\n";
-//}
-
-/*#################################################################################*/
-/*--------------------------------private methods----------------------------------*/
-/*---------------------------------------------------------------------------------*/
-
-void GridGpuStrategy::allocDistribution(SPtr<GridImp> grid)
-{
- CudaSafeCall(cudaMemcpyToSymbol(DIRECTIONS, grid->distribution.dirs, grid->distribution.dir_end * DIMENSION * sizeof(int)));
- CudaCheckError();
-
- unsigned long long distributionSize = grid->size * (grid->distribution.dir_end + 1);
- unsigned long long size_in_bytes = distributionSize * sizeof(real);
- real sizeInMB = size_in_bytes / (1024.f*1024.f);
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "Allocating " << sizeInMB << " [MB] device memory for distributions.\n\n";
-
- CudaSafeCall(cudaMalloc(&grid->distribution.f, size_in_bytes));
- CudaCheckError();
-}
-
-void GridGpuStrategy::allocNeighborsIndices(SPtr<GridImp> grid)
-{
- int size_in_bytes_neighbors = grid->size * sizeof(int);
- int *neighborIndexX, *neighborIndexY, *neighborIndexZ, *neighborIndexNegative;;
-
- CudaSafeCall(cudaMalloc(&neighborIndexX, size_in_bytes_neighbors));
- CudaSafeCall(cudaMalloc(&neighborIndexY, size_in_bytes_neighbors));
- CudaSafeCall(cudaMalloc(&neighborIndexZ, size_in_bytes_neighbors));
- CudaSafeCall(cudaMalloc(&neighborIndexNegative, size_in_bytes_neighbors));
-
- grid->neighborIndexX = neighborIndexX;
- grid->neighborIndexY = neighborIndexY;
- grid->neighborIndexZ = neighborIndexZ;
- grid->neighborIndexNegative = neighborIndexNegative;
-
- CudaCheckError();
-}
-
-void GridGpuStrategy::allocMatrixIndicesOnGPU(SPtr<GridImp> grid)
-{
- int size_in_bytes_nodes_reduced = grid->size * sizeof(int);
- int* indices_reduced_d;
- CudaSafeCall(cudaMalloc(&indices_reduced_d, size_in_bytes_nodes_reduced));
- grid->sparseIndices = indices_reduced_d;
- CudaCheckError();
-}
-
-
-void GridGpuStrategy::allocAndCopyTrianglesToGPU(TriangularMesh &geom)
-{
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "start copying triangles ...\n";
- //clock_t begin = clock();
- int size_in_bytes_triangles = sizeof(Triangle)*geom.size;
- real sizeInMB = size_in_bytes_triangles / (1024.f*1024.f);
-
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "Allocating " << sizeInMB << " [MB] device memory for triangles.\n\n";
-
- Triangle *triangles_d;
- CudaSafeCall(cudaMalloc(&triangles_d, size_in_bytes_triangles));
- CudaSafeCall(cudaMemcpy(triangles_d, geom.triangles, size_in_bytes_triangles, cudaMemcpyHostToDevice));
- geom.triangles = triangles_d;
- CudaCheckError();
- //clock_t end = clock();
- //real time = real(end - begin) / CLOCKS_PER_SEC;
- //*logging::out << logging::Logger::INFO_INTERMEDIATE << "time copying triangles: " << time << "s\n";
- *logging::out << logging::Logger::INFO_INTERMEDIATE << "...copying triangles finish!\n\n";
-}
-
-void GridGpuStrategy::freeTrianglesFromGPU(const TriangularMesh &geom)
-{
- CudaSafeCall(cudaFree(geom.triangles));
- CudaCheckError();
-}
-
-void GridGpuStrategy::allocAndCopyMatrixIndicesToGPU(SPtr<GridImp> grid, const uint& size)
-{
- int size_in_bytes_nodes_reduced = size * sizeof(int);
- int* indices_reduced_d;
- CudaSafeCall(cudaMalloc(&indices_reduced_d, size_in_bytes_nodes_reduced));
- CudaSafeCall(cudaMemcpy(indices_reduced_d, grid->sparseIndices, size_in_bytes_nodes_reduced, cudaMemcpyHostToDevice));
- delete[] grid->sparseIndices;
- grid->sparseIndices = indices_reduced_d;
- CudaCheckError();
-}
-
-void GridGpuStrategy::allocAndCopyFieldToGPU(Field& field)
-{
- int size_in_bytes_grid = field.getSize() * sizeof(char);
- char* field_d;
- CudaSafeCall(cudaMalloc(&field_d, size_in_bytes_grid));
- CudaSafeCall(cudaMemcpy(field_d, field.field, size_in_bytes_grid, cudaMemcpyHostToDevice));
- delete[] field.field;
- field.field = field_d;
- CudaCheckError();
-}
-
-void GridGpuStrategy::copyAndFreeFieldFromGPU(Field& field)
-{
- char *field_h = new char[field.size];
- CudaSafeCall(cudaMemcpy(field_h, field.field, field.size * sizeof(char), cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaFree(field.field));
- CudaCheckError();
- field.field = field_h;
-}
-
-void GridGpuStrategy::copyAndFreeDistributiondFromGPU(SPtr<GridImp> grid)
-{
- unsigned long long distributionSize = grid->size * (grid->distribution.dir_end + 1);
- real *f_host = new real[distributionSize];
- CudaSafeCall(cudaMemcpy(f_host, grid->distribution.f, distributionSize * sizeof(real), cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaFree(grid->distribution.f));
- CudaCheckError();
- grid->distribution.f = f_host;
-}
-
-
-
-void GridGpuStrategy::copyAndFreeNeighborsToCPU(SPtr<GridImp> grid)
-{
- int size_in_bytes_neighbors = grid->size * sizeof(int);
- int *neighborIndexX_h, *neighborIndexY_h, *neighborIndexZ_h, *neighborIndexNegative_h;
- neighborIndexX_h = new int[grid->size];
- neighborIndexY_h = new int[grid->size];
- neighborIndexZ_h = new int[grid->size];
- neighborIndexNegative_h = new int[grid->size];
-
- CudaSafeCall(cudaMemcpy(neighborIndexX_h, grid->neighborIndexX, size_in_bytes_neighbors, cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaMemcpy(neighborIndexY_h, grid->neighborIndexY, size_in_bytes_neighbors, cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaMemcpy(neighborIndexZ_h, grid->neighborIndexZ, size_in_bytes_neighbors, cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaMemcpy(neighborIndexNegative_h, grid->neighborIndexNegative, size_in_bytes_neighbors, cudaMemcpyDeviceToHost));
-
- CudaSafeCall(cudaFree(grid->neighborIndexX));
- CudaSafeCall(cudaFree(grid->neighborIndexY));
- CudaSafeCall(cudaFree(grid->neighborIndexZ));
- CudaSafeCall(cudaFree(grid->neighborIndexNegative));
-
- grid->neighborIndexX = neighborIndexX_h;
- grid->neighborIndexY = neighborIndexY_h;
- grid->neighborIndexZ = neighborIndexZ_h;
- grid->neighborIndexNegative = neighborIndexNegative_h;
- CudaCheckError();
-}
-
-void GridGpuStrategy::copyAndFreeMatrixIndicesFromGPU(SPtr<GridImp> grid, int size)
-{
- int size_in_bytes_nodes_reduced = size * sizeof(int);
- int *indices_reduced_h = new int[size];
- CudaSafeCall(cudaMemcpy(indices_reduced_h, grid->sparseIndices, size_in_bytes_nodes_reduced, cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaFree(grid->sparseIndices));
- grid->sparseIndices = indices_reduced_h;
- CudaCheckError();
-}
-
-
-void GridGpuStrategy::copyAndFreeGridInterfaceFromGPU(SPtr<GridImp> grid)
-{
- GridInterface *gridInterface = new GridInterface();
- CudaSafeCall(cudaMemcpy(gridInterface, grid->gridInterface, sizeof(GridInterface), cudaMemcpyDeviceToHost));
-
- uint *cfc = new uint[gridInterface->cf.numberOfEntries];
- uint *cff = new uint[gridInterface->cf.numberOfEntries];
- uint *fcc = new uint[gridInterface->fc.numberOfEntries];
- uint *fcf = new uint[gridInterface->fc.numberOfEntries];
-
-
- CudaSafeCall(cudaMemcpy(cfc, gridInterface->cf.coarse, gridInterface->cf.numberOfEntries * sizeof(uint), cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaMemcpy(cff, gridInterface->cf.fine, gridInterface->cf.numberOfEntries * sizeof(uint), cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaMemcpy(fcc, gridInterface->fc.coarse, gridInterface->fc.numberOfEntries * sizeof(uint), cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaMemcpy(fcf, gridInterface->fc.fine, gridInterface->fc.numberOfEntries * sizeof(uint), cudaMemcpyDeviceToHost));
- CudaSafeCall(cudaFree(gridInterface->cf.coarse));
- CudaSafeCall(cudaFree(gridInterface->cf.fine));
- CudaSafeCall(cudaFree(gridInterface->fc.coarse));
- CudaSafeCall(cudaFree(gridInterface->fc.fine));
- CudaSafeCall(cudaFree(grid->gridInterface));
-
- grid->gridInterface = gridInterface;
- grid->gridInterface->cf.coarse = cfc;
- grid->gridInterface->cf.fine = cff;
- grid->gridInterface->fc.coarse = fcc;
- grid->gridInterface->fc.fine = fcf;
- CudaCheckError();
-}
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h b/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
deleted file mode 100644
index fb886824ad35e6657f49c23a3fc25e19aabf0783..0000000000000000000000000000000000000000
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef GRID_GPU_STRATEGY_H
-#define GRID_GPU_STRATEGY_H
-
-#include "global.h"
-
-#include "grid/GridStrategy/GridStrategy.h"
-
-class BoundingBox;
-class TriangularMesh;
-
-class GRIDGENERATOR_EXPORT GridGpuStrategy : public GridStrategy
-{
-public:
- virtual ~GridGpuStrategy() {};
-
- void allocateGridMemory(SPtr<GridImp> grid) override;
-
- void allocateQs(SPtr<GridImp> grid) override;
-
- void initalNodesToOutOfGrid(SPtr<GridImp> grid) override;
- void fixOddCells(SPtr<GridImp> grid) override;
- void findInnerNodes(SPtr<GridImp> grid) override;
- void addOverlap(SPtr<GridImp> grid) override;
- void fixRefinementIntoWall(SPtr<GridImp> grid) override;
- void findStopperNodes(SPtr<GridImp> grid) override;
- void findBoundarySolidNodes(SPtr<GridImp> grid) override;
- void findEndOfGridStopperNodes(SPtr<GridImp> grid) override;
- void findSolidStopperNodes(SPtr<GridImp> grid) override;
-
- void mesh(SPtr<GridImp> grid, TriangularMesh &geom) override;
-
- uint closeNeedleCells(SPtr<GridImp> grid) override;
- uint closeNeedleCellsThinWall(SPtr<GridImp> grid) override;
-
- void findQs(SPtr<GridImp> grid, TriangularMesh &geom) override;
-
-
- void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid, LbmOrGks lbmOrGks) override;
-
- void freeMemory(SPtr<GridImp> grid) override;
-
-
-
- void copyAndFreeGridInterfaceFromGPU(SPtr<GridImp> grid);
- virtual void copyDataFromGPU(SPtr<GridImp> grid);
-
- //void markNodesToDeleteOutsideOfGeometry();
-
-private:
- void allocField(SPtr<GridImp> grid);
- void allocDistribution(SPtr<GridImp> grid);
- void allocNeighborsIndices(SPtr<GridImp> grid);
- void allocMatrixIndicesOnGPU(SPtr<GridImp> grid);
-
- void allocAndCopyTrianglesToGPU(TriangularMesh &geom);
- void freeTrianglesFromGPU(const TriangularMesh &geom);
-
-
- void allocAndCopyMatrixIndicesToGPU(SPtr<GridImp> grid, const uint& size);
-
- void allocAndCopyFieldToGPU(Field& field);
- void copyAndFreeFieldFromGPU(Field& field);
-
- void copyAndFreeDistributiondFromGPU(SPtr<GridImp> grid);
-
- void copyAndFreeNeighborsToCPU(SPtr<GridImp> grid);
- void copyAndFreeMatrixIndicesFromGPU(SPtr<GridImp> grid, int size);
-
-public:
- void allocateFieldMemory(Field* field) override;
- void freeFieldMemory(Field* field) override;
- void findSparseIndices(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid) override;
-
-};
-
-#endif
diff --git a/src/gpu/GridGenerator/grid/GridStrategy/GridStrategy.h b/src/gpu/GridGenerator/grid/GridStrategy/GridStrategy.h
deleted file mode 100644
index f1cf20f258a8676f5c6aa146f5bafcdb21b025ff..0000000000000000000000000000000000000000
--- a/src/gpu/GridGenerator/grid/GridStrategy/GridStrategy.h
+++ /dev/null
@@ -1,81 +0,0 @@
-//=======================================================================================
-// ____ ____ __ ______ __________ __ __ __ __
-// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
-// \ \ | | | | | |_) | | | | | | | / \ | |
-// \ \ | | | | | _ / | | | | | | / /\ \ | |
-// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
-// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
-// \ \ | | ________________________________________________________________
-// \ \ | | | ______________________________________________________________|
-// \ \| | | | __ __ __ __ ______ _______
-// \ | | |_____ | | | | | | | | | _ \ / _____)
-// \ | | _____| | | | | | | | | | | \ \ \_______
-// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
-// \ _____| |__| |________| \_______/ |__| |______/ (_______/
-//
-// This file is part of VirtualFluids. VirtualFluids is free software: you can
-// redistribute it and/or modify it under the terms of the GNU General Public
-// License as published by the Free Software Foundation, either version 3 of
-// the License, or (at your option) any later version.
-//
-// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
-// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-// for more details.
-//
-// You should have received a copy of the GNU General Public License along
-// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
-//
-//! \file GridStrategy.h
-//! \ingroup grid
-//! \author Soeren Peters, Stephan Lenz
-//=======================================================================================
-#ifndef GRID_STRATEGY_H
-#define GRID_STRATEGY_H
-
-#include "Core/LbmOrGks.h"
-
-#include "global.h"
-
-#include "grid/Field.h"
-
-struct Vertex;
-class TriangularMesh;
-class GridImp;
-
-class GRIDGENERATOR_EXPORT GridStrategy
-{
-public:
- virtual void allocateFieldMemory(Field *field) = 0;
- virtual void freeFieldMemory(Field *field) = 0;
-
- virtual void allocateGridMemory(SPtr<GridImp> grid) = 0;
-
- virtual void allocateQs(SPtr<GridImp> grid) = 0;
-
- virtual void initalNodesToOutOfGrid(SPtr<GridImp> grid) = 0;
- virtual void fixOddCells(SPtr<GridImp> grid) = 0;
- virtual void findInnerNodes(SPtr<GridImp> grid) = 0;
- virtual void addOverlap(SPtr<GridImp> grid) = 0;
-
- virtual void fixRefinementIntoWall(SPtr<GridImp> grid) = 0;
- virtual void findStopperNodes(SPtr<GridImp> grid) = 0;
- virtual void findBoundarySolidNodes(SPtr<GridImp> grid) = 0;
- virtual void findEndOfGridStopperNodes(SPtr<GridImp> grid) = 0;
- virtual void findSolidStopperNodes(SPtr<GridImp> grid) = 0;
-
- virtual void mesh(SPtr<GridImp> grid, TriangularMesh &geom) = 0;
-
- virtual uint closeNeedleCells(SPtr<GridImp> grid) = 0;
- virtual uint closeNeedleCellsThinWall(SPtr<GridImp> grid) = 0;
-
- virtual void findQs(SPtr<GridImp> grid, TriangularMesh &geom) = 0;
-
- virtual void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid, LbmOrGks lbmOrGks) = 0;
-
- virtual void findSparseIndices(SPtr<GridImp> coarseGrid, SPtr<GridImp> fineGrid) = 0;
-
- virtual void freeMemory(SPtr<GridImp> grid) = 0;
-};
-
-#endif