diff --git a/src/GridGenerator/geometries/Object.cu b/src/GridGenerator/geometries/Object.cu
index f04b03a63daf3a65f365257fafde2ebfc9ee0415..0fae18f668f14d86356b3e4a04be3a9f284dc1a0 100644
--- a/src/GridGenerator/geometries/Object.cu
+++ b/src/GridGenerator/geometries/Object.cu
@@ -6,3 +6,8 @@ void Object::findInnerNodes(SPtr<GridImp> grid)
{
grid->getGridStrategy()->findInnerNodes( grid );
}
+
+HOST int Object::getIntersection(const Vertex & P, const Vertex & direction, Vertex & pointOnObject, real & qVal)
+{
+ return 1;
+}
diff --git a/src/GridGenerator/geometries/Object.h b/src/GridGenerator/geometries/Object.h
index 86428a7574c3f277667aaee504c4c3e5e64f864d..9a32abbf6b676877235afe9a193c1ae64cd3402f 100644
--- a/src/GridGenerator/geometries/Object.h
+++ b/src/GridGenerator/geometries/Object.h
@@ -12,6 +12,7 @@
#include "global.h"
class GridImp;
+struct Vertex;
class VF_PUBLIC Object
{
@@ -48,6 +49,8 @@ public:
}
HOST virtual void findInnerNodes(SPtr<GridImp> grid);
+
+ HOST virtual int getIntersection(const Vertex &P, const Vertex &direction, Vertex &pointOnObject, real &qVal);
};
diff --git a/src/GridGenerator/geometries/Sphere/Sphere.cu b/src/GridGenerator/geometries/Sphere/Sphere.cu
index 894c1710f68e150b34984fd0b36a4da67fb5f715..7e93c98df737604686a7bf8994dbf4234266b385 100644
--- a/src/GridGenerator/geometries/Sphere/Sphere.cu
+++ b/src/GridGenerator/geometries/Sphere/Sphere.cu
@@ -1,5 +1,9 @@
#include "Sphere.h"
+#include <algorithm> // std::min
+
+#include "geometries/Vertex/Vertex.h"
+
Sphere::Sphere(const double& centerX, const double& centerY, const double& centerZ, const double& radius)
: centerX(centerX), centerY(centerY), centerZ(centerZ), radius(radius)
{
@@ -85,3 +89,49 @@ void Sphere::scale(double delta)
{
this->radius += delta;
}
+
+HOST int Sphere::getIntersection(const Vertex & point, const Vertex & direction, Vertex & pointOnObject, real & qVal)
+{
+
+ Vertex relativePoint( point.x - this->centerX,
+ point.y - this->centerY,
+ point.z - this->centerZ );
+
+ real directionSquare = direction.x * direction.x
+ + direction.y * direction.y
+ + direction.z * direction.z;
+
+ real p = 2* ( relativePoint.x * direction.x
+ + relativePoint.y * direction.y
+ + relativePoint.z * direction.z )
+ / directionSquare;
+
+ real q = ( relativePoint.x * relativePoint.x
+ + relativePoint.y * relativePoint.y
+ + relativePoint.z * relativePoint.z
+ - this->radius * this->radius )
+ / directionSquare;
+
+ real discriminant = 0.25 * p * p - q;
+
+
+ if( discriminant < 0.0 ) return 1;
+
+ real result1 = - 0.5 * p + std::sqrt( discriminant );
+ real result2 = - 0.5 * p - std::sqrt( discriminant );
+
+ if( result1 < 0.0 && result2 < 0.0 ) return 1;
+
+ if( result1 < 0.0 ) result1 = 1e99;
+ if( result2 < 0.0 ) result2 = 1e99;
+
+ real t = std::min( result1, result2 );
+
+ pointOnObject.x = point.x + t * direction.x;
+ pointOnObject.y = point.y + t * direction.y;
+ pointOnObject.z = point.z + t * direction.z;
+
+ qVal = t;
+
+ return 0;
+}
diff --git a/src/GridGenerator/geometries/Sphere/Sphere.h b/src/GridGenerator/geometries/Sphere/Sphere.h
index 7ca12037a515846f9e9fc24de9a2e362237c5172..988c2a131e86264ec51335b4c19ad7764c6c673f 100644
--- a/src/GridGenerator/geometries/Sphere/Sphere.h
+++ b/src/GridGenerator/geometries/Sphere/Sphere.h
@@ -35,7 +35,10 @@ public:
void scale(double delta) override;
-
+
+ HOST int getIntersection(const Vertex &P, const Vertex &direction, Vertex &pointOnObject, real &qVal) override;
+
+
protected:
double centerX;
double centerY;
diff --git a/src/GridGenerator/grid/GridImp.cu b/src/GridGenerator/grid/GridImp.cu
index 2445a7b7c5caaaf6ca4f9205df8f9f60a8dbb601..84c64cba3263e82a7e66080eeacc2c83b36ae18f 100644
--- a/src/GridGenerator/grid/GridImp.cu
+++ b/src/GridGenerator/grid/GridImp.cu
@@ -1225,6 +1225,8 @@ HOST void GridImp::findQs(Object* object) //TODO: enable qs for primitive object
TriangularMesh* triangularMesh = dynamic_cast<TriangularMesh*>(object);
if (triangularMesh)
findQs(*triangularMesh);
+ else
+ findQsPrimitive(object);
}
HOST void GridImp::findQs(TriangularMesh &triangularMesh)
@@ -1286,6 +1288,114 @@ HOSTDEVICE void GridImp::findQs(Triangle &triangle)
}
}
+HOST void GridImp::findQsPrimitive(Object * object)
+{
+
+ if( this->qComputationStage == qComputationStageType::ComputeQs ){
+ gridStrategy->allocateQs(shared_from_this());
+ }
+
+
+ for( int index = 0; index < this->size; index++ )
+ {
+
+ if( this->qIndices[index] == INVALID_INDEX ) continue;
+
+ real x,y,z;
+
+ this->transIndexToCoords(index,x,y,z);
+
+ const Vertex point(x, y, z);
+
+ if( this->qComputationStage == qComputationStageType::ComputeQs ){
+ if(this->field.is(index, BC_SOLID))
+ {
+ calculateQs(index, point, object);
+ }
+ }
+ else if( this->qComputationStage == qComputationStageType::FindSolidBoundaryNodes )
+ {
+ if( !this->field.is(index, FLUID) ) continue;
+
+ if( checkIfAtLeastOneValidQ(index, point, object) )
+ {
+ // similar as in void GridImp::findBoundarySolidNode(uint index)
+ this->field.setFieldEntry( index, BC_SOLID );
+ this->qIndices[index] = this->numberOfSolidBoundaryNodes++;
+ }
+ }
+
+ }
+}
+
+HOSTDEVICE void GridImp::calculateQs(const uint index, const Vertex &point, Object* object) const
+{
+ Vertex pointOnTriangle, direction;
+
+ real subdistance;
+ int error;
+ for (int i = distribution.dir_start; i <= distribution.dir_end; i++)
+ {
+ direction = Vertex( real(distribution.dirs[i * DIMENSION + 0]),
+ real(distribution.dirs[i * DIMENSION + 1]),
+ real(distribution.dirs[i * DIMENSION + 2]) );
+
+ uint neighborIndex = this->transCoordToIndex(point.x + direction.x * this->delta,
+ point.y + direction.y * this->delta,
+ point.z + direction.z * this->delta);
+
+ if (neighborIndex == INVALID_INDEX) continue;
+
+ error = object->getIntersection(point, direction, pointOnTriangle, subdistance);
+
+ subdistance /= this->delta;
+
+ if (error == 0 && vf::Math::lessEqual(subdistance, 1.0) && vf::Math::greaterEqual(subdistance, 0.0))
+ {
+ if ( -0.5 > this->qValues[i*this->numberOfSolidBoundaryNodes + this->qIndices[index]] ||
+ subdistance < this->qValues[i*this->numberOfSolidBoundaryNodes + this->qIndices[index]] )
+ {
+
+ this->qValues[i*this->numberOfSolidBoundaryNodes + this->qIndices[index]] = subdistance;
+
+ this->qPatches[ this->qIndices[index] ] = 0;
+
+ //printf("%d %f \n", this->qIndices[index], subdistance);
+ }
+ }
+ }
+}
+
+HOSTDEVICE bool GridImp::checkIfAtLeastOneValidQ(const uint index, const Vertex &point, Object* object) const
+{
+ Vertex pointOnTriangle, direction;
+
+ real subdistance;
+ int error;
+ for (int i = distribution.dir_start; i <= distribution.dir_end; i++)
+ {
+ direction = Vertex( real(distribution.dirs[i * DIMENSION + 0]),
+ real(distribution.dirs[i * DIMENSION + 1]),
+ real(distribution.dirs[i * DIMENSION + 2]) );
+
+ uint neighborIndex = this->transCoordToIndex(point.x + direction.x * this->delta,
+ point.y + direction.y * this->delta,
+ point.z + direction.z * this->delta);
+
+ if (neighborIndex == INVALID_INDEX) continue;
+
+ error = object->getIntersection(point, direction, pointOnTriangle, subdistance);
+
+ subdistance /= this->delta;
+
+ if (error == 0 && vf::Math::lessEqual(subdistance, 1.0) && vf::Math::greaterEqual(subdistance, 0.0))
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
HOSTDEVICE void GridImp::setDebugPoint(uint index, int pointValue)
{
if (field.isInvalidCoarseUnderFine(index) && pointValue == INVALID_SOLID)
@@ -1329,7 +1439,6 @@ HOSTDEVICE void GridImp::calculateQs(const Vertex &point, const Triangle &triang
HOSTDEVICE void GridImp::calculateQs(const uint index, const Vertex &point, const Triangle &triangle) const
{
Vertex pointOnTriangle, direction;
- //VertexInteger solid_node;
real subdistance;
int error;
for (int i = distribution.dir_start; i <= distribution.dir_end; i++)
@@ -1348,14 +1457,6 @@ HOSTDEVICE void GridImp::calculateQs(const uint index, const Vertex &point, cons
if (neighborIndex == INVALID_INDEX) continue;
- //if ( this->field.is(neighborIndex, STOPPER_SOLID) )
- // {
- // if (this->qValues[i*this->numberOfSolidBoundaryNodes + this->qIndices[index]] < -0.5)
- // {
- // this->qValues[i*this->numberOfSolidBoundaryNodes + this->qIndices[index]] = 1.0;
- // }
- // }
-
error = triangle.getTriangleIntersection(point, direction, pointOnTriangle, subdistance);
subdistance /= this->delta;
@@ -1378,7 +1479,6 @@ HOSTDEVICE void GridImp::calculateQs(const uint index, const Vertex &point, cons
HOSTDEVICE bool GridImp::checkIfAtLeastOneValidQ(const uint index, const Vertex & point, const Triangle & triangle) const
{
Vertex pointOnTriangle, direction;
- //VertexInteger solid_node;
real subdistance;
int error;
for (int i = distribution.dir_start; i <= distribution.dir_end; i++)
@@ -1386,8 +1486,9 @@ HOSTDEVICE bool GridImp::checkIfAtLeastOneValidQ(const uint index, const Vertex
#if defined(__CUDA_ARCH__)
direction = Vertex(DIRECTIONS[i][0], DIRECTIONS[i][1], DIRECTIONS[i][2]);
#else
- direction = Vertex(real(distribution.dirs[i * DIMENSION + 0]), real(distribution.dirs[i * DIMENSION + 1]),
- real(distribution.dirs[i * DIMENSION + 2]));
+ direction = Vertex(real(distribution.dirs[i * DIMENSION + 0]),
+ real(distribution.dirs[i * DIMENSION + 1]),
+ real(distribution.dirs[i * DIMENSION + 2]));
#endif
uint neighborIndex = this->transCoordToIndex(point.x + direction.x * this->delta,
diff --git a/src/GridGenerator/grid/GridImp.h b/src/GridGenerator/grid/GridImp.h
index b2d55efb796ff4b7062f672b8067493dde8b6c7b..3eebd60340e3ef7ba83a649efc96bd72bf38e8cb 100644
--- a/src/GridGenerator/grid/GridImp.h
+++ b/src/GridGenerator/grid/GridImp.h
@@ -260,6 +260,8 @@ public:
HOST void findQs(Object* object) override;
HOST void findQs(TriangularMesh &triangularMesh);
HOSTDEVICE void findQs(Triangle &triangle);
+
+ HOST void findQsPrimitive(Object* object);
private:
enum class qComputationStageType{
@@ -275,7 +277,11 @@ private:
HOSTDEVICE void setDebugPoint(uint index, int pointValue);
HOSTDEVICE void calculateQs(const Vertex &point, const Triangle &triangle) const;
HOSTDEVICE void calculateQs(const uint index, const Vertex &point, const Triangle &triangle) const;
- HOSTDEVICE bool checkIfAtLeastOneValidQ(const uint index, const Vertex &point, const Triangle &triangle) const;
+ HOST void calculateQs(const uint index, const Vertex &point, Object* object) const;
+
+ HOST bool checkIfAtLeastOneValidQ(const uint index, const Vertex &point, const Triangle &triangle) const;
+
+ HOST bool checkIfAtLeastOneValidQ(const uint index, const Vertex &point, Object* object) const;
public:
diff --git a/targets/apps/LBM/gridGeneratorTest/gridGeneratorTest.cpp b/targets/apps/LBM/gridGeneratorTest/gridGeneratorTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..866770733534061ccf5010f7ceb29c5b5b6cd101
--- /dev/null
+++ b/targets/apps/LBM/gridGeneratorTest/gridGeneratorTest.cpp
@@ -0,0 +1,822 @@
+//#define MPI_LOGGING
+
+//Martin Branch
+
+#include <mpi.h>
+#if defined( MPI_LOGGING )
+ #include <mpe.h>
+#endif
+
+#include <string>
+#include <iostream>
+#include <stdexcept>
+#include <fstream>
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include "Core/LbmOrGks.h"
+#include "Core/Input/Input.h"
+#include "Core/StringUtilities/StringUtil.h"
+#include "Core/Input/ConfigFileReader/ConfigFileReader.h"
+
+#include "VirtualFluids_GPU/LBM/Simulation.h"
+#include "VirtualFluids_GPU/Communication/Communicator.h"
+#include "VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h"
+#include "VirtualFluids_GPU/DataStructureInitializer/GridProvider.h"
+#include "VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.h"
+#include "VirtualFluids_GPU/Parameter/Parameter.h"
+#include "VirtualFluids_GPU/Output/FileWriter.h"
+
+#include "VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.h"
+#include "VirtualFluids_GPU/PreProcessor/PreProcessorFactory/PreProcessorFactoryImp.h"
+
+#include "VirtualFluids_GPU/GPU/CudaMemoryManager.h"
+#include "VirtualFluids_GPU/Kernel/Utilities/Mapper/KernelMapper/KernelMapper.h"
+
+#include "global.h"
+
+#include "geometries/Sphere/Sphere.h"
+#include "geometries/VerticalCylinder/VerticalCylinder.h"
+#include "geometries/Cuboid/Cuboid.h"
+#include "geometries/TriangularMesh/TriangularMesh.h"
+#include "geometries/Conglomerate/Conglomerate.h"
+#include "geometries/TriangularMesh/TriangularMeshStrategy.h"
+
+#include "grid/GridBuilder/LevelGridBuilder.h"
+#include "grid/GridBuilder/MultipleGridBuilder.h"
+#include "grid/BoundaryConditions/Side.h"
+#include "grid/BoundaryConditions/BoundaryCondition.h"
+#include "grid/GridFactory.h"
+
+#include "io/SimulationFileWriter/SimulationFileWriter.h"
+#include "io/GridVTKWriter/GridVTKWriter.h"
+#include "io/STLReaderWriter/STLReader.h"
+#include "io/STLReaderWriter/STLWriter.h"
+
+#include "utilities/math/Math.h"
+#include "utilities/communication.h"
+#include "utilities/transformator/TransformatorImp.h"
+
+
+void multipleLevel(const std::string& configPath)
+{
+ std::ofstream logFile( "F:/Work/Computations/out/Sphere/gridGeneratorLog.txt" );
+ //std::ofstream logFile( "grid/gridGeneratorLog.txt" );
+ logging::Logger::addStream(&logFile);
+
+ logging::Logger::addStream(&std::cout);
+ logging::Logger::setDebugLevel(logging::Logger::Level::INFO_LOW);
+ logging::Logger::timeStamp(logging::Logger::ENABLE);
+ logging::Logger::enablePrintedRankNumbers(logging::Logger::ENABLE);
+
+ //UbLog::reportingLevel() = UbLog::logLevelFromString("DEBUG5");
+
+ auto gridFactory = GridFactory::make();
+ gridFactory->setGridStrategy(Device::CPU);
+ //gridFactory->setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod::RAYCASTING);
+ gridFactory->setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod::POINT_IN_OBJECT);
+ //gridFactory->setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod::POINT_UNDER_TRIANGLE);
+
+ auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
+
+ Communicator* comm = Communicator::getInstanz();
+ SPtr<ConfigFileReader> configReader = ConfigFileReader::getNewInstance();
+ SPtr<ConfigData> configData = configReader->readConfigFile(configPath);
+
+ std::shared_ptr<KernelMapper> kernelMapper = KernelMapper::getInstance();
+
+ SPtr<Parameter> para = Parameter::make(configData, comm);
+
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ bool useGridGenerator = true;
+
+ if(useGridGenerator){
+
+ enum testCase{
+ TGV,
+ TGV3D,
+ SphereTest,
+ DrivAer,
+ PaperPlane,
+ DLC,
+ MultiGPU,
+ StlGroupTest
+ };
+
+ int testcase = SphereTest;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if (testcase == TGV)
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+ real dx = 1.0;
+ real vx = 0.049;
+ //////////////////////////////////////////////////////////////////////////
+ //32
+ gridBuilder->addCoarseGrid(-24, -2, -16,
+ 24, 2, 16, dx);
+ //////////////////////////////////////////////////////////////////////////
+ gridBuilder->setPeriodicBoundaryCondition(true, true, true);
+ //////////////////////////////////////////////////////////////////////////
+ gridBuilder->buildGrids(LBM, true);
+ //////////////////////////////////////////////////////////////////////////
+ SPtr<Grid> grid = gridBuilder->getGrid(gridBuilder->getNumberOfLevels() - 1);
+ //////////////////////////////////////////////////////////////////////////
+ gridBuilder->writeGridsToVtk("E:/temp/TaylorGreenVortex/results/32/TGV32turned_Grid");
+ gridBuilder->writeArrows("E:/temp/TaylorGreenVortex/results/32/TGV32turned_Grid_arrow");
+ //////////////////////////////////////////////////////////////////////////
+ SimulationFileWriter::write("E:/temp/TaylorGreenVortex/grids/turned/gridUni48x4x32/", gridBuilder, FILEFORMAT::BINARY);
+ //////////////////////////////////////////////////////////////////////////
+ return;
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if (testcase == TGV3D)
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+ const real PI = 3.141592653589793238462643383279;
+
+ real dx = 2.0 * PI / 32.0; // 32^3 nodes
+ //real dx = 2.0 * PI / 64.0; // 64^3 nodes
+ //real dx = 2.0 * PI / 128.0; // 128^3 nodes
+ //real dx = 2.0 * PI / 256.0; // 128^3 nodes
+ real vx = 0.049;
+
+ gridBuilder->addCoarseGrid(-PI, -PI, -PI,
+ PI, PI, PI, dx);
+
+ gridBuilder->setPeriodicBoundaryCondition(true, true, true);
+
+ gridBuilder->buildGrids(LBM, true); // buildGrids() has to be called before setting the BCs!!!!
+ ////////////////////////////////////////////////////////////////////////////
+ //gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx, 0.0, 0.0);
+ //gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx, 0.0, 0.0);
+ //gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx, 0.0, 0.0);
+ //gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx, 0.0, 0.0);
+
+ //gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+ //gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
+
+ //gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ //////////////////////////////////////////////////////////////////////////
+ SPtr<Grid> grid = gridBuilder->getGrid(gridBuilder->getNumberOfLevels() - 1);
+ //////////////////////////////////////////////////////////////////////////
+ //32
+ gridBuilder->writeGridsToVtk("E:/temp/TaylorGreenVortex/results3D/32/TGV3D_Grid");
+ gridBuilder->writeArrows("E:/temp/TaylorGreenVortex/results3D/32/TGV3D_Grid_arrow");
+ SimulationFileWriter::write("E:/temp/TaylorGreenVortex/grids3D/gridTGV3D/32/", gridBuilder, FILEFORMAT::BINARY); //FILEFORMAT::ASCII
+ //256
+ //gridBuilder->writeGridsToVtk("E:/temp/TaylorGreenVortex/results3D/256/TGV3D_Grid");
+ //gridBuilder->writeArrows("E:/temp/TaylorGreenVortex/results3D/256/TGV3D_Grid_arrow");
+ //SimulationFileWriter::write("E:/temp/TaylorGreenVortex/grids3D/gridTGV3D/256/", gridBuilder, FILEFORMAT::BINARY); //FILEFORMAT::ASCII
+
+ return;
+
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if( testcase == SphereTest)
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+ real dx = 1.0 / 16.0;
+ real vx = 0.0125;
+
+ real D = 1.0;
+ real Re = 1140000;
+
+ para->setOutputPath( "F:/Work/Computations/out/Sphere/" );
+ para->setOutputPrefix( "Sphere" );
+
+ para->setFName(para->getOutputPath() + "/" + para->getOutputPrefix());
+
+ para->setPrintFiles(true);
+
+ para->setVelocity( vx );
+ para->setViscosity( ( vx * D / dx ) / Re );
+
+ para->setVelocityRatio(1.0);
+
+ para->setTOut( 1000 );
+ para->setTEnd( 100000 );
+
+ para->setUseWale(false);
+
+ para->setMainKernel(kernelMapper->getEnum("CumulantK20Comp"));
+
+ //////////////////////////////////////////////////////////////////////////
+
+ TriangularMesh* sphereSTL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/Sphere/SphereNotOptimal.stl");
+
+ TriangularMesh* sphereRef_1_STL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/Sphere/SphereRef_1.stl");
+
+ TriangularMesh* sphereRef_2_STL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/Sphere/SphereRef_2.stl");
+
+ Object* sphere = new Sphere( 0, 0, 0, 0.5*D );
+
+ gridBuilder->addCoarseGrid(-2.0*D, -5.5*D, -5.5*D,
+ 9.0*D, 5.5*D, 5.5*D, dx); // DrivAer
+
+ //gridBuilder->setNumberOfLayers(10,8);
+ //gridBuilder->addGrid(SphereSTL, 2);
+
+ gridBuilder->setNumberOfLayers(4,8);
+ gridBuilder->addGrid(sphereRef_1_STL, 3);
+ gridBuilder->addGrid(sphereRef_2_STL, 4);
+
+ gridBuilder->setNumberOfLayers(10,8);
+ gridBuilder->addGrid(sphere, 5);
+
+
+
+ //gridBuilder->addGeometry(SphereSTL);
+ gridBuilder->addGeometry(sphere);
+
+ gridBuilder->setPeriodicBoundaryCondition(false, false, false);
+
+ gridBuilder->buildGrids(LBM, true); // buildGrids() has to be called before setting the BCs!!!!
+ //////////////////////////////////////////////////////////////////////////
+ gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx , 0.0, 0.0);
+
+ gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ //////////////////////////////////////////////////////////////////////////
+ SPtr<Grid> grid = gridBuilder->getGrid(gridBuilder->getNumberOfLevels() - 1);
+ //////////////////////////////////////////////////////////////////////////
+
+ //gridBuilder->writeGridsToVtk("F:/Work/Computations/out/Sphere/grid");
+ //gridBuilder->writeArrows ("F:/Work/Computations/out/Sphere/arrow");
+
+ SimulationFileWriter::write("F:/Work/Computations/out/Sphere/grid/", gridBuilder, FILEFORMAT::BINARY);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if( testcase == DrivAer )
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+
+ real dx = 0.2;
+ real vx = 0.05;
+
+ real L = 4.6;
+ real Re = 1.0e6;
+
+ para->setOutputPath( "F:/Work/Computations/out/DrivAerNew/" );
+ para->setOutputPrefix( "DrivAer" );
+
+ para->setFName(para->getOutputPath() + "/" + para->getOutputPrefix());
+
+ para->setPrintFiles(true);
+
+ para->setVelocity( vx );
+ para->setViscosity( ( vx * L / dx ) / Re );
+
+ //para->setVelocityRatio(1.0 / velocityLB);
+ para->setVelocityRatio(1.0);
+
+ para->setTOut( 10000 );
+ para->setTEnd( 100000 );
+
+ para->setUseWale(false);
+
+ para->setMainKernel(kernelMapper->getEnum("CumulantK20Comp"));
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ TriangularMesh* DrivAerSTL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/DrivAer_Fastback_Coarse.stl");
+ //TriangularMesh* triangularMesh = TriangularMesh::make("M:/TestGridGeneration/STL/DrivAer_NoSTLGroups.stl");
+ //TriangularMesh* triangularMesh = TriangularMesh::make("M:/TestGridGeneration/STL/DrivAer_Coarse.stl");
+ //TriangularMesh* DrivAerSTL = TriangularMesh::make("stl/DrivAer_Fastback_Coarse.stl");
+
+ TriangularMesh* DrivAerRefBoxSTL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/DrivAer_REF_BOX_Adrea.stl");
+ //TriangularMesh* DrivAerRefBoxSTL = TriangularMesh::make("stl/DrivAer_REF_BOX_Adrea.stl");
+
+ real z0 = 0.318;
+
+ gridBuilder->addCoarseGrid(- 5.0, -5.0, 0.0 - z0,
+ 15.0, 5.0, 5.0 - z0, dx); // DrivAer
+
+ //Object* floorBox = new Cuboid( -0.3, -1, -1, 4.0, 1, 0.2 );
+ //Object* wakeBox = new Cuboid( 3.5, -1, -1, 5.5, 1, 0.8 );
+
+ //Conglomerate* refRegion = new Conglomerate();
+
+ //refRegion->add(floorBox);
+ //refRegion->add(wakeBox);
+ //refRegion->add(DrivAerRefBoxSTL);
+
+ gridBuilder->setNumberOfLayers(10,8);
+ gridBuilder->addGrid(DrivAerRefBoxSTL, 4);
+
+ gridBuilder->setNumberOfLayers(10,8);
+ gridBuilder->addGrid(DrivAerSTL, 5);
+
+ gridBuilder->addGeometry(DrivAerSTL);
+
+ gridBuilder->setPeriodicBoundaryCondition(false, false, false);
+
+ gridBuilder->buildGrids(LBM, true); // buildGrids() has to be called before setting the BCs!!!!
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx , 0.0, 0.0);
+
+ gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ SPtr<Grid> grid = gridBuilder->getGrid(gridBuilder->getNumberOfLevels() - 1);
+
+ gridBuilder->getGeometryBoundaryCondition(gridBuilder->getNumberOfLevels() - 1)->setTangentialVelocityForPatch( grid, 4, 0.0075, -2.0, 0.0,
+ 0.0075, 2.0, 0.0, -vx, 0.318);
+ gridBuilder->getGeometryBoundaryCondition(gridBuilder->getNumberOfLevels() - 1)->setTangentialVelocityForPatch( grid, 3, 2.793 , -2.0, 0.0,
+ 2.793 , 2.0, 0.0, -vx, 0.318);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->writeGridsToVtk("F:/Work/Computations/out/DrivAerNew/DrivAer_Grid_");
+ gridBuilder->writeArrows ("F:/Work/Computations/out/DrivAerNew/DrivAer_Grid_arrow");
+
+ //SimulationFileWriter::write("D:/GRIDGENERATION/files/", gridBuilder, FILEFORMAT::ASCII);
+ //SimulationFileWriter::write("C:/Users/lenz/Desktop/Work/gridGenerator/grid/", gridBuilder, FILEFORMAT::ASCII);
+ SimulationFileWriter::write("F:/Work/Computations/out/DrivAerNew/grid/", gridBuilder, FILEFORMAT::BINARY);
+ //SimulationFileWriter::write("grid/", gridBuilder, FILEFORMAT::ASCII);
+
+ //return;
+ //gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if( testcase == PaperPlane )
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+
+ real dx = 0.01;
+ real vx = 0.05;
+
+ real L = 0.3;
+ real Re = 90000;
+
+ para->setOutputPath( "F:/Work/Computations/out/PaperPlane/" );
+ para->setOutputPrefix( "PaperPlaneK17winglet" );
+
+ para->setFName(para->getOutputPath() + "/" + para->getOutputPrefix());
+
+ para->setPrintFiles(true);
+
+ para->setVelocity( vx );
+ para->setViscosity( ( vx * L / dx ) / Re );
+
+ para->setVelocityRatio(1.0);
+
+ para->setTOut( 1000 );
+ para->setTEnd( 100000 );
+
+ para->setUseWale(false);
+
+ para->setMainKernel(kernelMapper->getEnum("CumulantAA2016CompSP27"));
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ TriangularMesh* STL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/PaperPlane_1.stl");
+ //TriangularMesh* STL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/PaperPlane_1_winglet.stl");
+
+ TriangularMesh* RefBoxSTL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/PaperPlane_1_ref.stl");
+ //TriangularMesh* RefBoxSTL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/PaperPlane_1_winglet_ref.stl");
+
+ gridBuilder->addCoarseGrid(- 0.5, -0.3, -0.3,
+ 1.0, 0.3, 0.3, dx);
+
+ gridBuilder->setNumberOfLayers(6,8);
+ gridBuilder->addGrid(RefBoxSTL, 3);
+
+ gridBuilder->addGeometry(STL);
+
+ gridBuilder->setPeriodicBoundaryCondition(false, false, false);
+
+ gridBuilder->buildGrids(LBM, true); // buildGrids() has to be called before setting the BCs!!!!
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx , 0.0, 0.0);
+
+ gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->writeGridsToVtk("F:/Work/Computations/out/PaperPlane/PaperPlane_Grid_");
+ gridBuilder->writeArrows ("F:/Work/Computations/out/PaperPlane/PaperPlane_Grid_arrow");
+
+ //SimulationFileWriter::write("D:/GRIDGENERATION/files/", gridBuilder, FILEFORMAT::ASCII);
+ //SimulationFileWriter::write("C:/Users/lenz/Desktop/Work/gridGenerator/grid/", gridBuilder, FILEFORMAT::ASCII);
+ SimulationFileWriter::write("F:/Work/Computations/out/PaperPlane/grid/", gridBuilder, FILEFORMAT::BINARY);
+ //SimulationFileWriter::write("grid/", gridBuilder, FILEFORMAT::ASCII);
+
+ //return;
+ //gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if( testcase == StlGroupTest )
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+
+ real dx = 0.025;
+ real vx = 0.05;
+
+ real L = 1.0;
+ real Re = 100;
+
+ para->setOutputPath( "F:/Work/Computations/out/StlGroupTest/" );
+ para->setOutputPrefix( "StlGroupTest" );
+
+ para->setFName(para->getOutputPath() + "/" + para->getOutputPrefix());
+
+ para->setPrintFiles(true);
+
+ para->setVelocity( vx );
+ para->setViscosity( ( vx * L / dx ) / Re );
+
+ para->setVelocityRatio(1.0);
+
+ para->setTOut( 1000 );
+ para->setTEnd( 100000 );
+
+ para->setUseWale(false);
+
+ para->setMainKernel(kernelMapper->getEnum("CumulantAA2016CompSP27"));
+ //para->setMainKernel(kernelMapper->getEnum("CumulantOneCompSP27"));
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ TriangularMesh* STL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/STL_Group_Test_2_Cylinders.stl");
+
+ gridBuilder->addCoarseGrid(- 2.0, -4.5, -2.0,
+ 4.0, 4.5, 2.0, dx);
+
+ gridBuilder->addGeometry(STL);
+
+ gridBuilder->setPeriodicBoundaryCondition(false, false, false);
+
+ gridBuilder->buildGrids(LBM, true); // buildGrids() has to be called before setting the BCs!!!!
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx , 0.0, 0.0);
+
+ gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ SPtr<Grid> grid = gridBuilder->getGrid(gridBuilder->getNumberOfLevels() - 1);
+
+ gridBuilder->getGeometryBoundaryCondition(gridBuilder->getNumberOfLevels() - 1)->setTangentialVelocityForPatch( grid, 1, 0.0, -2.0, 0.0,
+ 0.0, 2.0, 0.0, -vx, 0.5);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->writeGridsToVtk("F:/Work/Computations/out/StlGroupTest/StlGroupTest_Grid_");
+ gridBuilder->writeArrows ("F:/Work/Computations/out/StlGroupTest/StlGroupTest_Grid_arrow");
+
+ SimulationFileWriter::write("F:/Work/Computations/out/StlGroupTest/grid/", gridBuilder, FILEFORMAT::BINARY);
+
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if( testcase == DLC )
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+ real velocityRatio = 594.093427;
+
+ real dx = 0.2;
+ real vx = 0.065272188;
+
+ real z0 = 0.24395 + 0.5*dx;
+
+ std::vector<uint> ignorePatches = { 152, 153, 154 };
+
+ //TriangularMesh* VW370_SERIE_STL = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/VW370_SERIE.stl", ignorePatches);
+ TriangularMesh* VW370_SERIE_STL = TriangularMesh::make("stl/VW370_SERIE.stl", ignorePatches);
+
+ //TriangularMesh* DLC_RefBox = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC_RefBox.stl");
+
+ //TriangularMesh* DLC_RefBox_1 = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC_RefBox_withWake/DLC_RefBox_withWake_4m.stl");
+ //TriangularMesh* DLC_RefBox_2 = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC_RefBox_withWake/DLC_RefBox_withWake_3m.stl");
+ //TriangularMesh* DLC_RefBox_3 = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC_RefBox_withWake/DLC_RefBox_withWake_2m.stl");
+ //TriangularMesh* DLC_RefBox_4 = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC_RefBox_withWake/DLC_RefBox_withWake_1m.stl");
+
+ //TriangularMesh* DLC_RefBox_Level_3 = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC/DLC_RefBox_Level_3.stl");
+ //TriangularMesh* DLC_RefBox_Level_4 = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC/DLC_RefBox_Level_4.stl");
+ //TriangularMesh* DLC_RefBox_Level_5 = TriangularMesh::make("C:/Users/lenz/Desktop/Work/gridGenerator/stl/DLC/DLC_RefBox_Level_5.stl");
+
+ TriangularMesh* DLC_RefBox_Level_3 = TriangularMesh::make("stl/DLC/DLC_RefBox_Level_3.stl");
+ TriangularMesh* DLC_RefBox_Level_4 = TriangularMesh::make("stl/DLC/DLC_RefBox_Level_4.stl");
+ TriangularMesh* DLC_RefBox_Level_5 = TriangularMesh::make("stl/DLC/DLC_RefBox_Level_5.stl");
+
+ //TriangularMesh* VW370_SERIE_STL = TriangularMesh::make("stl/VW370_SERIE.stl", ignorePatches);
+ //TriangularMesh* DLC_RefBox = TriangularMesh::make("stl/DLC_RefBox.lnx.stl");
+ //TriangularMesh* DLC_RefBox_4 = TriangularMesh::make("stl/DLC_RefBox_withWake/DLC_RefBox_withWake_1m.lnx.stl");
+
+ gridBuilder->addCoarseGrid(-30.0, -20.0, 0.0 - z0,
+ 50.0, 20.0, 25.0 - z0, dx);
+
+ gridBuilder->setNumberOfLayers(10,8);
+ gridBuilder->addGrid( new Cuboid( - 6.6, -6, -0.7, 20.6 , 6, 5.3 ), 1 );
+ gridBuilder->addGrid( new Cuboid( -3.75, -3, -0.7, 11.75, 3, 2.65 ), 2 );
+
+ gridBuilder->setNumberOfLayers(10,8);
+ gridBuilder->addGrid(DLC_RefBox_Level_3, 3);
+ gridBuilder->addGrid(DLC_RefBox_Level_4, 4);
+
+ Conglomerate* refinement = new Conglomerate();
+ refinement->add(DLC_RefBox_Level_5);
+ refinement->add(VW370_SERIE_STL);
+
+ gridBuilder->setNumberOfLayers(10,8);
+ gridBuilder->addGrid(refinement, 5);
+
+ gridBuilder->addGeometry(VW370_SERIE_STL);
+
+ gridBuilder->setPeriodicBoundaryCondition(false, false, false);
+
+ gridBuilder->buildGrids(LBM, true); // buildGrids() has to be called before setting the BCs!!!!
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx , 0.0, 0.0);
+
+ gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ SPtr<Grid> grid = gridBuilder->getGrid(gridBuilder->getNumberOfLevels() - 1);
+
+ real wheelsFrontX = -0.081;
+ real wheelsRearX = 2.5486;
+
+ real wheelsFrontZ = 0.0504;
+ real wheelsRearZ = 0.057;
+
+ real wheelsRadius = 0.318;
+
+ real wheelRotationFrequency = 1170.74376 / 60.0;
+
+ real wheelTangentialVelocity = -2.0 * M_PI * wheelsRadius * wheelRotationFrequency / velocityRatio;
+
+ std::vector<uint> frontWheelPatches = { 71, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 159 };
+ std::vector<uint> rearWheelPatches = { 82, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 160 };
+
+ for( uint patch : frontWheelPatches ){
+ gridBuilder->getGeometryBoundaryCondition(gridBuilder->getNumberOfLevels() - 1)->setTangentialVelocityForPatch( grid, patch, wheelsFrontX, -2.0, wheelsFrontZ,
+ wheelsFrontX, 2.0, wheelsFrontZ,
+ wheelTangentialVelocity, wheelsRadius);
+ }
+
+ for( uint patch : rearWheelPatches ){
+ gridBuilder->getGeometryBoundaryCondition(gridBuilder->getNumberOfLevels() - 1)->setTangentialVelocityForPatch( grid, patch, wheelsRearX , -2.0, wheelsRearZ ,
+ wheelsRearX , 2.0, wheelsRearZ ,
+ wheelTangentialVelocity, wheelsRadius);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+
+ //gridBuilder->writeGridsToVtk("C:/Users/lenz/Desktop/Work/gridGenerator/grid/DLC_Grid");
+ //gridBuilder->writeArrows ("C:/Users/lenz/Desktop/Work/gridGenerator/grid/DLC_Grid_arrow");
+
+ gridBuilder->writeGridsToVtk("grid/DLC_Grid");
+ gridBuilder->writeArrows ("grid/DLC_Grid_arrow");
+
+ //SimulationFileWriter::write("D:/GRIDGENERATION/files/", gridBuilder, FILEFORMAT::ASCII);
+ //SimulationFileWriter::write("C:/Users/lenz/Desktop/Work/gridGenerator/grid/", gridBuilder, FILEFORMAT::ASCII);
+ SimulationFileWriter::write("grid/", gridBuilder, FILEFORMAT::ASCII);
+
+ //gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+ }
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ if( testcase == MultiGPU )
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ {
+ //const uint generatePart = 1;
+ const uint generatePart = Communicator::getInstanz()->getPID();
+
+ std::ofstream logFile2;
+
+ if( generatePart == 0 )
+ logFile2.open( "F:/Work/Computations/gridGenerator/grid/0/gridGeneratorLog.txt" );
+ //logFile2.open( "grid/0/gridGeneratorLog.txt" );
+
+ if( generatePart == 1 )
+ logFile2.open( "F:/Work/Computations/gridGenerator/grid/1/gridGeneratorLog.txt" );
+ //logFile2.open( "grid/1/gridGeneratorLog.txt" );
+
+ logging::Logger::addStream(&logFile2);
+
+ real dx = 1.0 / 40.0;
+ real vx = 0.05;
+
+ TriangularMesh* triangularMesh = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/ShpereNotOptimal.stl");
+ //TriangularMesh* triangularMesh = TriangularMesh::make("stl/ShpereNotOptimal.lnx.stl");
+
+ // all
+ //gridBuilder->addCoarseGrid(-2, -2, -2,
+ // 4, 2, 2, dx);
+
+ real overlap = 10.0 * dx;
+
+ if( generatePart == 0 )
+ gridBuilder->addCoarseGrid(-2.0 , -2.0, -2.0,
+ 0.5 + overlap, 2.0, 2.0, dx);
+
+ if( generatePart == 1 )
+ gridBuilder->addCoarseGrid( 0.5 - overlap, -2.0, -2.0,
+ 4.0 , 2.0, 2.0, dx);
+
+
+ gridBuilder->setNumberOfLayers(10,8);
+ gridBuilder->addGrid(triangularMesh, 1);
+
+ gridBuilder->addGeometry(triangularMesh);
+
+ if( generatePart == 0 )
+ gridBuilder->setSubDomainBox( std::make_shared<BoundingBox>( -2.0, 0.5,
+ -2.0, 2.0,
+ -2.0, 2.0 ) );
+
+ if( generatePart == 1 )
+ gridBuilder->setSubDomainBox( std::make_shared<BoundingBox>( 0.5, 4.0,
+ -2.0, 2.0,
+ -2.0, 2.0 ) );
+
+ gridBuilder->setPeriodicBoundaryCondition(false, false, false);
+
+ gridBuilder->buildGrids(LBM, true); // buildGrids() has to be called before setting the BCs!!!!
+
+ if( generatePart == 0 ){
+ gridBuilder->findCommunicationIndices(CommunicationDirections::PX, LBM);
+ gridBuilder->setCommunicationProcess(CommunicationDirections::PX, 1);
+ }
+
+ if( generatePart == 1 ){
+ gridBuilder->findCommunicationIndices(CommunicationDirections::MX, LBM);
+ gridBuilder->setCommunicationProcess(CommunicationDirections::MX, 0);
+ }
+
+ //////////////////////////////////////////////////////////////////////////
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx , 0.0, 0.0);
+ gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx , 0.0, 0.0);
+
+ if (generatePart == 0) {
+ gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
+ }
+ if (generatePart == 1) {
+ gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
+ }
+
+ gridBuilder->setVelocityBoundaryCondition(SideType::GEOMETRY, 0.0, 0.0, 0.0);
+
+ //////////////////////////////////////////////////////////////////////////
+
+ if (generatePart == 0) {
+ //gridBuilder->writeGridsToVtk("F:/Work/Computations/gridGenerator/grid/0/Test_");
+ //gridBuilder->writeArrows ("F:/Work/Computations/gridGenerator/grid/0/Test_Arrow");
+ }
+ if (generatePart == 1) {
+ //gridBuilder->writeGridsToVtk("F:/Work/Computations/gridGenerator/grid/1/Test_");
+ //gridBuilder->writeArrows ("F:/Work/Computations/gridGenerator/grid/1/Test_Arrow");
+ }
+
+ if (generatePart == 0)
+ SimulationFileWriter::write("F:/Work/Computations/gridGenerator/grid/0/", gridBuilder, FILEFORMAT::ASCII);
+ //SimulationFileWriter::write("grid/0/", gridBuilder, FILEFORMAT::ASCII);
+ if (generatePart == 1)
+ SimulationFileWriter::write("F:/Work/Computations/gridGenerator/grid/1/", gridBuilder, FILEFORMAT::ASCII);
+ //SimulationFileWriter::write("grid/1/", gridBuilder, FILEFORMAT::ASCII);
+
+ //return;
+
+ //gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+ }
+
+ }
+ else
+ {
+ //gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+ //gridGenerator = GridProvider::makeGridReader(FILEFORMAT::BINARY, para, cudaMemoryManager);
+ }
+
+ logFile.close();
+
+ //return;
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ SPtr<CudaMemoryManager> cudaMemoryManager = CudaMemoryManager::make(para);
+
+ SPtr<GridProvider> gridGenerator;
+ if( useGridGenerator ) gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
+ else gridGenerator = GridProvider::makeGridReader(FILEFORMAT::BINARY, para, cudaMemoryManager);
+
+ Simulation sim;
+
+ SPtr<FileWriter> fileWriter = SPtr<FileWriter>(new FileWriter());
+
+ SPtr<KernelFactoryImp> kernelFactory = KernelFactoryImp::getInstance();
+
+ SPtr<PreProcessorFactoryImp> preProcessorFactory = PreProcessorFactoryImp::getInstance();
+
+ sim.setFactories(kernelFactory, preProcessorFactory);
+
+ sim.init(para, gridGenerator, fileWriter, cudaMemoryManager);
+
+
+ sim.run();
+ sim.free();
+}
+
+int main( int argc, char* argv[])
+{
+ MPI_Init(&argc, &argv);
+ std::string str, str2;
+ if ( argv != NULL )
+ {
+ //str = static_cast<std::string>(argv[0]);
+
+ try
+ {
+ //////////////////////////////////////////////////////////////////////////
+
+ std::string targetPath;
+
+ targetPath = __FILE__;
+
+#ifdef _WIN32
+ targetPath = targetPath.substr(0, targetPath.find_last_of('\\') + 1);
+#else
+ targetPath = targetPath.substr(0, targetPath.find_last_of('/') + 1);
+#endif
+
+ std::cout << targetPath << std::endl;
+
+ multipleLevel(targetPath + "config.txt");
+
+ //////////////////////////////////////////////////////////////////////////
+ }
+ catch (const std::exception& e)
+ {
+
+ *logging::out << logging::Logger::LOGGER_ERROR << e.what() << "\n";
+ }
+ catch (const std::bad_alloc e)
+ {
+
+ *logging::out << logging::Logger::LOGGER_ERROR << "Bad Alloc:" << e.what() << "\n";
+ }
+ catch (...)
+ {
+ *logging::out << logging::Logger::LOGGER_ERROR << "Unknown exception!\n";
+ }
+ }
+
+ MPI_Finalize();
+ return 0;
+}
diff --git a/targets/apps/LBM/gridGeneratorTest/main.cpp b/targets/apps/LBM/gridGeneratorTest/main.cpp
deleted file mode 100644
index ab2167e8c9cbe1a2e0d2a4cf2957ce885a7af5b4..0000000000000000000000000000000000000000
--- a/targets/apps/LBM/gridGeneratorTest/main.cpp
+++ /dev/null
@@ -1,260 +0,0 @@
-
-#define _USE_MATH_DEFINES
-#include <math.h>
-#include <string>
-#include <sstream>
-#include <iostream>
-#include <stdexcept>
-#include <fstream>
-#include <exception>
-#include <memory>
-
-//////////////////////////////////////////////////////////////////////////
-
-#include "Core/DataTypes.h"
-#include "Core/PointerDefinitions.h"
-
-#include "Core/LbmOrGks.h"
-#include "Core/Input/Input.h"
-#include "Core/StringUtilities/StringUtil.h"
-#include "Core/Input/ConfigFileReader/ConfigFileReader.h"
-
-#include "Core/VectorTypes.h"
-#include "Core/Logger/Logger.h"
-
-//////////////////////////////////////////////////////////////////////////
-
-#include "GridGenerator/grid/GridBuilder/LevelGridBuilder.h"
-#include "GridGenerator/grid/GridBuilder/MultipleGridBuilder.h"
-#include "GridGenerator/grid/BoundaryConditions/Side.h"
-#include "GridGenerator/grid/GridFactory.h"
-
-#include "GridGenerator/geometries/Cuboid/Cuboid.h"
-#include "GridGenerator/geometries/TriangularMesh/TriangularMesh.h"
-#include "GridGenerator/geometries/Conglomerate/Conglomerate.h"
-#include "GridGenerator/geometries/TriangularMesh/TriangularMeshStrategy.h"
-
-#include "GridGenerator/io/SimulationFileWriter/SimulationFileWriter.h"
-#include "GridGenerator/io/GridVTKWriter/GridVTKWriter.h"
-#include "GridGenerator/io/STLReaderWriter/STLReader.h"
-#include "GridGenerator/io/STLReaderWriter/STLWriter.h"
-
-//////////////////////////////////////////////////////////////////////////
-
-#include "VirtualFluids_GPU/LBM/Simulation.h"
-#include "VirtualFluids_GPU/Communication/Communicator.h"
-#include "VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h"
-#include "VirtualFluids_GPU/DataStructureInitializer/GridProvider.h"
-#include "VirtualFluids_GPU/DataStructureInitializer/GridReaderFiles/GridReader.h"
-#include "VirtualFluids_GPU/Parameter/Parameter.h"
-#include "VirtualFluids_GPU/Output/FileWriter.h"
-
-#include "VirtualFluids_GPU/Kernel/Utilities/KernelFactory/KernelFactoryImp.h"
-#include "VirtualFluids_GPU/PreProcessor/PreProcessorFactory/PreProcessorFactoryImp.h"
-
-#include "VirtualFluids_GPU/GPU/CudaMemoryManager.h"
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//
-// U s e r s e t t i n g s
-//
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-//LbmOrGks lbmOrGks = GKS;
-//LbmOrGks lbmOrGks = LBM;
-
-const real L = 2.0;
-
-const real Re = 100000.0;
-
-const real velocity = 1.0;
-
-const real dt = 0.25e-3;
-
-const uint nx = 32;
-
-std::string path("F:/Work/Computations/out/gridGeneratorTest/"); //LEGOLAS
-//std::string path("E:/DrivenCavity/results/"); //TESLA03
-
-std::string simulationName("DrivenCavity");
-
-const uint timeStepOut = 10;
-const uint timeStepEnd = 1000000;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void multipleLevel(const std::string& configPath)
-{
- logging::Logger::addStream(&std::cout);
- logging::Logger::setDebugLevel(logging::Logger::Level::INFO_LOW);
- logging::Logger::timeStamp(logging::Logger::ENABLE);
- logging::Logger::enablePrintedRankNumbers(logging::Logger::ENABLE);
-
- auto gridFactory = GridFactory::make();
- gridFactory->setGridStrategy(Device::CPU);
- gridFactory->setTriangularMeshDiscretizationMethod(TriangularMeshDiscretizationMethod::POINT_IN_OBJECT);
-
- auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
-
- Communicator* comm = Communicator::getInstanz();
- SPtr<ConfigFileReader> configReader = ConfigFileReader::getNewInstance();
- SPtr<ConfigData> configData = configReader->readConfigFile(configPath);
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- real dx = L / real(nx);
-
- gridBuilder->addCoarseGrid(-L, -L, -L,
- L, L, L, dx);
-
- TriangularMesh* cylinderSTL = TriangularMesh::make("F:/Work/Computations/gridGenerator/stl/Cylinder.stl");
-
-
- gridBuilder->setNumberOfLayers(6,6);
- gridBuilder->addGrid(cylinderSTL, 1);
-
- //Object* cube = new Cuboid(-0.5,-0.5,-0.5,0.5,0.5,0.5);
- //gridBuilder->addGrid(cube, 1);
-
- gridBuilder->addGeometry(cylinderSTL);
-
- gridBuilder->setPeriodicBoundaryCondition(false, false, false);
-
- gridBuilder->buildGrids(LBM, false); // buildGrids() has to be called before setting the BCs!!!!
-
- gridBuilder->writeGridsToVtk("F:/Work/Computations/out/gridGeneratorTest/grid_");
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- SPtr<Parameter> para = Parameter::make(configData, comm);
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- const real velocityLB = velocity * dt / dx; // LB units
-
- const real vx = velocityLB; // LB units
-
- const real viscosityLB = nx * velocityLB / Re; // LB units
-
- *logging::out << logging::Logger::INFO_HIGH << "velocity [dx/dt] = " << velocityLB << " \n";
- *logging::out << logging::Logger::INFO_HIGH << "viscosity [dx/dt] = " << viscosityLB << "\n";
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- para->setOutputPath( path );
- para->setOutputPrefix( simulationName );
-
- para->setFName(para->getOutputPath() + "/" + para->getOutputPrefix());
-
- para->setPrintFiles(true);
-
- para->setVelocity(velocityLB);
- para->setViscosity(viscosityLB);
-
- //para->setVelocityRatio(1.0 / velocityLB);
- para->setVelocityRatio(1.0);
-
- para->setTOut( timeStepOut );
- para->setTEnd( timeStepEnd );
-
- para->setUseWale(false);
-
- /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- gridBuilder->setVelocityBoundaryCondition(SideType::MX, vx, 0.0, 0.0);
- gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
- //gridBuilder->setVelocityBoundaryCondition(SideType::PX, 0.0, 0.0, 0.0);
- gridBuilder->setVelocityBoundaryCondition(SideType::PY, vx, 0.0, 0.0);
- gridBuilder->setVelocityBoundaryCondition(SideType::MY, vx, 0.0, 0.0);
- gridBuilder->setVelocityBoundaryCondition(SideType::PZ, vx, 0.0, 0.0);
- gridBuilder->setVelocityBoundaryCondition(SideType::MZ, vx, 0.0, 0.0);
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- SimulationFileWriter::write("F:/Work/Computations/out/gridGeneratorTest/grid/", gridBuilder, FILEFORMAT::BINARY);
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
- SPtr<CudaMemoryManager> cudaMemoryManager = CudaMemoryManager::make(para);
- SPtr<GridProvider> gridGenerator = GridProvider::makeGridGenerator(gridBuilder, para, cudaMemoryManager);
- //SPtr<GridProvider> gridGenerator = GridProvider::makeGridReader(FILEFORMAT::BINARY, para, cudaMemoryManager);
-
- Simulation sim;
- SPtr<FileWriter> fileWriter = SPtr<FileWriter>(new FileWriter());
- SPtr<KernelFactoryImp> kernelFactory = KernelFactoryImp::getInstance();
- SPtr<PreProcessorFactoryImp> preProcessorFactory = PreProcessorFactoryImp::getInstance();
- sim.setFactories(kernelFactory, preProcessorFactory);
- sim.init(para, gridGenerator, fileWriter, cudaMemoryManager);
-
-
- sim.run();
- sim.free();
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-}
-
-int main( int argc, char* argv[])
-{
- MPI_Init(&argc, &argv);
- std::string str, str2;
- if ( argv != NULL )
- {
- //str = static_cast<std::string>(argv[0]);
-
- try
- {
- //////////////////////////////////////////////////////////////////////////
-
- std::string targetPath;
-
- targetPath = __FILE__;
-
-#ifdef _WIN32
- targetPath = targetPath.substr(0, targetPath.find_last_of('\\') + 1);
-#else
- targetPath = targetPath.substr(0, targetPath.find_last_of('/') + 1);
-#endif
-
- std::cout << targetPath << std::endl;
-
- multipleLevel(targetPath + "config.txt");
-
- //////////////////////////////////////////////////////////////////////////
- }
- catch (const std::exception& e)
- {
-
- *logging::out << logging::Logger::LOGGER_ERROR << e.what() << "\n";
- }
- catch (const std::bad_alloc e)
- {
-
- *logging::out << logging::Logger::LOGGER_ERROR << "Bad Alloc:" << e.what() << "\n";
- }
- catch (...)
- {
- *logging::out << logging::Logger::LOGGER_ERROR << "Unknown exception!\n";
- }
- }
-
- MPI_Finalize();
- return 0;
-}