From 55c92dc74b0c6bd3aecc5394f027f685d6b57dd5 Mon Sep 17 00:00:00 2001
From: Soeren Peters <peters@irmb.tu-bs.de>
Date: Tue, 22 May 2018 10:59:34 +0200
Subject: [PATCH] - add velocity values and qs to simulation from gridGenerator
---
src/GridGenerator/grid/Grid.h | 3 +
.../grid/GridBuilder/GridBuilder.h | 6 +
.../grid/GridBuilder/LevelGridBuilder.cpp | 54 +++++
.../grid/GridBuilder/LevelGridBuilder.h | 219 +++++++++++++++++-
.../grid/GridBuilder/MultipleGridBuilder.cpp | 7 +
src/GridGenerator/grid/GridImp.cu | 12 +
src/GridGenerator/grid/GridImp.h | 6 +-
src/GridGenerator/grid/GridMocks.h | 3 +
.../GridReaderGenerator/GridGenerator.cpp | 156 +++++++++++--
.../GridReaderGenerator/GridGenerator.h | 16 +-
targets/apps/HULC/main.cpp | 30 ++-
11 files changed, 476 insertions(+), 36 deletions(-)
diff --git a/src/GridGenerator/grid/Grid.h b/src/GridGenerator/grid/Grid.h
index 178c9d6c7..c3d05b330 100644
--- a/src/GridGenerator/grid/Grid.h
+++ b/src/GridGenerator/grid/Grid.h
@@ -72,6 +72,9 @@ public:
HOST virtual void setPeriodicity(bool periodicityX, bool periodicityY, bool periodicityZ) = 0;
+ HOST virtual void setPeriodicityX(bool periodicity) = 0;
+ HOST virtual void setPeriodicityY(bool periodicity) = 0;
+ HOST virtual void setPeriodicityZ(bool periodicity) = 0;
HOST virtual void freeMemory() = 0;
diff --git a/src/GridGenerator/grid/GridBuilder/GridBuilder.h b/src/GridGenerator/grid/GridBuilder/GridBuilder.h
index 78521d070..35b2702e4 100644
--- a/src/GridGenerator/grid/GridBuilder/GridBuilder.h
+++ b/src/GridGenerator/grid/GridBuilder/GridBuilder.h
@@ -64,6 +64,12 @@ public:
virtual void setOffsetFC(real* xOffCf, real* yOffCf, real* zOffCf, int level) = 0;
virtual void setOffsetCF(real* xOffFc, real* yOffFc, real* zOffFc, int level) = 0;
+
+
+
+ virtual uint getVelocitySize(int level) const = 0;
+ virtual void getVelocityValues(real* vx, real* vy, real* vz, int* indices, int level) const = 0;
+ virtual void getVelocityQs(real* qs[27], int level) const = 0;
};
#endif
diff --git a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
index b5badc0a3..7b3d256dc 100644
--- a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
+++ b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
@@ -48,6 +48,12 @@ std::shared_ptr<LevelGridBuilder> LevelGridBuilder::makeShared(Device device, co
return SPtr<LevelGridBuilder>(new LevelGridBuilder(device, d3qxx));
}
+void LevelGridBuilder::setVelocityBoundaryCondition(SPtr<Side> side, SPtr<VelocityBoundaryCondition> boundaryCondition)
+{
+ side->setPeriodicy(grids[0]);
+ velocityBoundaryConditions.push_back(boundaryCondition);
+ boundaryCondition->side = side;
+}
void LevelGridBuilder::copyDataFromGpu()
{
@@ -197,6 +203,54 @@ void LevelGridBuilder::setOutflowValues(real* RhoBC, int* kN, int channelSide, i
}
}
+
+uint LevelGridBuilder::getVelocitySize(int level) const
+{
+ uint size = 0;
+ for (auto boundaryCondition : this->velocityBoundaryConditions)
+ {
+ size += boundaryCondition->indices.size();
+ }
+ return size;
+}
+
+void LevelGridBuilder::getVelocityValues(real* vx, real* vy, real* vz, int* indices, int level) const
+{
+ int allIndicesCounter = 0;
+ for (auto boundaryCondition : this->velocityBoundaryConditions)
+ {
+ for(int i = 0; i < boundaryCondition->indices.size(); i++)
+ {
+ indices[allIndicesCounter] = boundaryCondition->indices[i];
+ vx[allIndicesCounter] = boundaryCondition->vx;
+ vy[allIndicesCounter] = boundaryCondition->vy;
+ vz[allIndicesCounter] = boundaryCondition->vz;
+ allIndicesCounter++;
+ }
+ }
+}
+
+void LevelGridBuilder::getVelocityQs(real* qs[27], int level) const
+{
+ int allIndicesCounter = 0;
+ for (auto boundaryCondition : this->velocityBoundaryConditions)
+ {
+ for (int i = 0; i < boundaryCondition->indices.size(); i++)
+ {
+
+ for (int dir = 0; dir < grids[level]->getEndDirection(); dir++)
+ {
+ if (grids[level]->getDirection()[dir * DIMENSION + boundaryCondition->side->getCoordinate()] != boundaryCondition->side->getDirection())
+ qs[dir][allIndicesCounter] = -1.0;
+ else
+ qs[dir][allIndicesCounter] = 0.5;
+ }
+ allIndicesCounter++;
+ }
+ }
+}
+
+
void LevelGridBuilder::setVelocityValues(real* vx, real* vy, real* vz, int channelSide, int level) const
{
for (int index = 0; index < Qs[channelSide].size(); index++) {
diff --git a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
index 0a8ac5ecf..3fd5b6ce9 100644
--- a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
+++ b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.h
@@ -6,24 +6,225 @@
#include <vector>
#include <string>
#include <memory>
+#include <map>
#include "GridBuilder.h"
#include "grid/GridInterface.h"
+#include "grid/Grid.h"
+#include "grid/NodeValues.h"
+
struct Vertex;
class Grid;
class Transformator;
class ArrowTransformator;
class PolyDataWriterWrapper;
-
+class BoundaryCondition;
class BoundingBox;
enum class Device;
-enum class BoundaryCondition
+class Side;
+
+class BoundaryCondition
+{
+public:
+ std::vector<uint> indices;
+
+};
+
+
+class VelocityBoundaryCondition : public BoundaryCondition
{
- PERIODIC, VELOCITY, PRESSURE, SLIP, NOSLIP
+public:
+ static SPtr<VelocityBoundaryCondition> make(real vx, real vy, real vz)
+ {
+ return SPtr<VelocityBoundaryCondition>(new VelocityBoundaryCondition(vx, vy, vz));
+ }
+
+ SPtr<Side> side;
+ real vx, vy, vz;
+private:
+ VelocityBoundaryCondition(real vx, real vy, real vz) : vx(vx), vy(vy), vz(vz)
+ {
+
+ }
};
+#define X_INDEX 0
+#define Y_INDEX 1
+#define Z_INDEX 2
+
+#define POSITIVE_DIR 1
+#define NEGATIVE_DIR -1
+
+class Side
+{
+public:
+ virtual void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition) = 0;
+ virtual void setPeriodicy(SPtr<Grid> grid) = 0;
+
+ virtual int getCoordinate() const = 0;
+ virtual int getDirection() const = 0;
+
+protected:
+ static void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition, std::string coord, real constant, real startInner, real endInner, real startOuter, real endOuter) {
+ for (int v1 = startInner; v1 < endInner; v1 += grid->getDelta())
+ {
+ for (int v2 = startOuter; v2 < endOuter; v2 += grid->getDelta())
+ {
+ uint index = getIndex(grid, coord, constant, v1, v2);
+ if (grid->getFieldEntry(index) == FLUID)
+ boundaryCondition->indices.push_back(index);
+ }
+ }
+ }
+
+ static uint getIndex(SPtr<Grid> grid, std::string coord, real constant, real v1, real v2)
+ {
+ if (coord == "x")
+ return grid->transCoordToIndex(constant, v1, v2);
+ if (coord == "y")
+ return grid->transCoordToIndex(v1, constant, v2);
+ if (coord == "z")
+ return grid->transCoordToIndex(v1, v2, constant);
+ }
+};
+
+class MX : public Side
+{
+public:
+ void setPeriodicy(SPtr<Grid> grid) override {
+ grid->setPeriodicityX(false);
+ }
+
+ void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition) override {
+ Side::addIndices(grid, boundaryCondition, "x", grid->getStartX() + grid->getDelta(), grid->getStartY(), grid->getEndY(),grid->getStartZ(), grid->getEndZ());
+ }
+
+ int getCoordinate() const override
+ {
+ return X_INDEX;
+ }
+
+ int getDirection() const override
+ {
+ return NEGATIVE_DIR;
+ }
+};
+
+class PX : public Side
+{
+public:
+ void setPeriodicy(SPtr<Grid> grid) override {
+ grid->setPeriodicityX(false);
+ }
+
+ void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition) override {
+ Side::addIndices(grid, boundaryCondition, "x", grid->getEndX() - grid->getDelta(), grid->getStartY(), grid->getEndY(), grid->getStartZ(), grid->getEndZ());
+ }
+
+ int getCoordinate() const override
+ {
+ return X_INDEX;
+ }
+
+ int getDirection() const override
+ {
+ return POSITIVE_DIR;
+ }
+};
+
+
+class MY : public Side
+{
+public:
+ void setPeriodicy(SPtr<Grid> grid) override {
+ grid->setPeriodicityY(false);
+ }
+
+ void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition) override {
+ Side::addIndices(grid, boundaryCondition, "y", grid->getStartY() + grid->getDelta(), grid->getStartX(), grid->getEndX(), grid->getStartZ(), grid->getEndZ());
+ }
+
+ int getCoordinate() const override
+ {
+ return Y_INDEX;
+ }
+
+ int getDirection() const override
+ {
+ return NEGATIVE_DIR;
+ }
+};
+
+class PY : public Side
+{
+public:
+ void setPeriodicy(SPtr<Grid> grid) override {
+ grid->setPeriodicityY(false);
+ }
+
+ void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition) override {
+ Side::addIndices(grid, boundaryCondition, "y", grid->getEndY() - grid->getDelta(), grid->getStartX(), grid->getEndX(), grid->getStartZ(), grid->getEndZ());
+ }
+
+ int getCoordinate() const override
+ {
+ return Y_INDEX;
+ }
+
+ int getDirection() const override
+ {
+ return POSITIVE_DIR;
+ }
+};
+
+
+class MZ : public Side
+{
+public:
+ void setPeriodicy(SPtr<Grid> grid) override {
+ grid->setPeriodicityZ(false);
+ }
+
+ void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition) override {
+ Side::addIndices(grid, boundaryCondition, "z", grid->getStartZ() + grid->getDelta(), grid->getStartX(), grid->getEndX(), grid->getStartY(), grid->getEndY());
+ }
+
+ int getCoordinate() const override
+ {
+ return Z_INDEX;
+ }
+
+ int getDirection() const override
+ {
+ return NEGATIVE_DIR;
+ }
+};
+
+class PZ : public Side
+{
+public:
+ void setPeriodicy(SPtr<Grid> grid) override {
+ grid->setPeriodicityZ(false);
+ }
+
+ void addIndices(SPtr<Grid> grid, SPtr<BoundaryCondition> boundaryCondition) override {
+ Side::addIndices(grid, boundaryCondition, "z", grid->getEndZ() - grid->getDelta(), grid->getStartX(), grid->getEndX(), grid->getStartY(), grid->getEndY());
+ }
+
+ int getCoordinate() const override
+ {
+ return Z_INDEX;
+ }
+
+ int getDirection() const override
+ {
+ return POSITIVE_DIR;
+ }
+};
+
+
class LevelGridBuilder : public GridBuilder
{
protected:
@@ -37,6 +238,7 @@ public:
VF_PUBLIC void copyDataFromGpu();
VF_PUBLIC virtual ~LevelGridBuilder();
+ VF_PUBLIC void setVelocityBoundaryCondition(SPtr<Side> side, SPtr<VelocityBoundaryCondition> boundaryCondition);
VF_PUBLIC virtual std::shared_ptr<Grid> getGrid(int level, int box);
@@ -60,6 +262,12 @@ public:
VF_PUBLIC virtual void setQs(real** q27, int* k, int channelSide, unsigned int level) const;
VF_PUBLIC virtual void setOutflowValues(real* RhoBC, int* kN, int channelSide, int level) const;
VF_PUBLIC virtual void setVelocityValues(real* vx, real* vy, real* vz, int channelSide, int level) const;
+
+ VF_PUBLIC uint getVelocitySize(int level) const;
+ VF_PUBLIC virtual void getVelocityValues(real* vx, real* vy, real* vz, int* indices, int level) const;
+ VF_PUBLIC virtual void getVelocityQs(real* qs[27], int level) const;
+
+
VF_PUBLIC virtual void setPressValues(real* RhoBC, int* kN, int channelSide, int level) const;
VF_PUBLIC void writeArrows(std::string fileName, std::shared_ptr<ArrowTransformator> trans) const;
@@ -67,10 +275,11 @@ public:
protected:
std::vector<std::shared_ptr<Grid> > grids;
-
std::vector<std::vector<std::vector<real> > > Qs;
std::vector<std::string> channelBoundaryConditions;
- std::vector<BoundaryCondition> channelBoundaryConditionTypes;
+ std::vector<SPtr<VelocityBoundaryCondition> > velocityBoundaryConditions;
+
+ //std::map<Side, BoundaryCondition> channelBoundaryConditionTypes;
void checkLevel(int level);
diff --git a/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp b/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
index 04a351dca..210aeae6e 100644
--- a/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
+++ b/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
@@ -263,6 +263,13 @@ void MultipleGridBuilder::buildGrids()
grids[i]->findSparseIndices(grids[i + 1]);
grids[grids.size() - 1]->findSparseIndices(nullptr);
+
+
+
+ for(auto velocityBC : velocityBoundaryConditions)
+ {
+ velocityBC->side->addIndices(grids[0], velocityBC);
+ }
}
diff --git a/src/GridGenerator/grid/GridImp.cu b/src/GridGenerator/grid/GridImp.cu
index ae4f1ef2c..f2f4c5d50 100644
--- a/src/GridGenerator/grid/GridImp.cu
+++ b/src/GridGenerator/grid/GridImp.cu
@@ -305,8 +305,20 @@ HOST void GridImp::setPeriodicity(bool periodicityX, bool periodicityY, bool per
this->periodicityZ = periodicityZ;
}
+void GridImp::setPeriodicityX(bool periodicity)
+{
+ this->periodicityX = periodicityX;
+}
+void GridImp::setPeriodicityY(bool periodicity)
+{
+ this->periodicityY = periodicityY;
+}
+void GridImp::setPeriodicityZ(bool periodicity)
+{
+ this->periodicityZ = periodicityZ;
+}
HOSTDEVICE int GridImp::transCoordToIndex(const real &x, const real &y, const real &z) const
{
diff --git a/src/GridGenerator/grid/GridImp.h b/src/GridGenerator/grid/GridImp.h
index 081c3deb9..40b88ece8 100644
--- a/src/GridGenerator/grid/GridImp.h
+++ b/src/GridGenerator/grid/GridImp.h
@@ -71,6 +71,10 @@ public:
HOSTDEVICE void removeOddBoundaryCellNode(uint index);
HOST void setPeriodicity(bool periodicityX, bool periodicityY, bool periodicityZ) override;
+ void setPeriodicityX(bool periodicity) override;
+ void setPeriodicityY(bool periodicity) override;
+ void setPeriodicityZ(bool periodicity) override;
+
HOSTDEVICE void setCellTo(uint index, char type);
HOSTDEVICE int transCoordToIndex(const real &x, const real &y, const real &z) const override;
@@ -176,7 +180,7 @@ private:
HOSTDEVICE void calculateQs(const Vertex &point, const Triangle &actualTriangle) const;
-public:
+
private:
//HOSTDEVICE bool isNeighborInside(const int &index) const;
diff --git a/src/GridGenerator/grid/GridMocks.h b/src/GridGenerator/grid/GridMocks.h
index acc119c2c..c87bd2363 100644
--- a/src/GridGenerator/grid/GridMocks.h
+++ b/src/GridGenerator/grid/GridMocks.h
@@ -67,6 +67,9 @@ public:
virtual Vertex getMinimumOnNode(Vertex exact) const override { return Vertex(0, 0, 0); }
virtual Vertex getMaximumOnNode(Vertex exact) const override { return Vertex(0, 0, 0); }
virtual void mesh(Object* object) override {}
+ void setPeriodicityX(bool periodicity) override {}
+ void setPeriodicityY(bool periodicity) override {}
+ void setPeriodicityZ(bool periodicity) override {}
};
class GridStub : public GridDummy
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
index 3bebefabe..dd99e1fb6 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.cpp
@@ -7,6 +7,7 @@
#include <sstream>
#include <iostream>
#include "utilities/math/Math.h"
+#include "LBM/LB.h"
std::shared_ptr<GridProvider> GridGenerator::make(std::shared_ptr<GridBuilder> builder, std::shared_ptr<Parameter> para)
@@ -124,14 +125,64 @@ void GridGenerator::allocArrays_BoundaryValues()
{
std::cout << "------read BoundaryValues------" << std::endl;
- channelBoundaryConditions = builder->getTypeOfBoundaryConditions();
-
- for (int i = 0; i < channelBoundaryConditions.size(); i++)
- {
- setVelocityValues(i);
- setPressureValues(i);
- setOutflowValues(i);
- }
+ for (int i = 0; i < builder->getNumberOfGridLevels(); i++) {
+ const int numberOfVelocityValues = int(builder->getVelocitySize(i));
+ if (numberOfVelocityValues > 1)
+ {
+ cout << "size velocity level " << i << " : " << numberOfVelocityValues << endl;
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ int blocks = (numberOfVelocityValues / para->getParH(i)->numberofthreads) + 1;
+ para->getParH(i)->Qinflow.kArray = blocks * para->getParH(i)->numberofthreads;
+ para->getParD(i)->Qinflow.kArray = para->getParH(i)->Qinflow.kArray;
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ para->getParH(i)->Qinflow.kQ = numberOfVelocityValues;
+ para->getParD(i)->Qinflow.kQ = numberOfVelocityValues;
+ para->getParH(i)->kInflowQ = numberOfVelocityValues;
+ para->getParD(i)->kInflowQ = numberOfVelocityValues;
+ para->getParH(i)->kInflowQread = numberOfVelocityValues * para->getD3Qxx();
+ para->getParD(i)->kInflowQread = numberOfVelocityValues * para->getD3Qxx();
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ para->cudaAllocVeloBC(i);
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ builder->getVelocityValues(para->getParH(i)->Qinflow.Vx, para->getParH(i)->Qinflow.Vy, para->getParH(i)->Qinflow.Vz, para->getParH(i)->Qinflow.k, i);
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+
+ //para->cudaCopyVeloBC(i);
+
+
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //// advection - diffusion stuff
+ //if (para->getDiffOn()==true){
+ // //////////////////////////////////////////////////////////////////////////
+ // para->getParH(i)->TempVel.kTemp = temp2;
+ // //cout << "Groesse kTemp = " << para->getParH(i)->TempPress.kTemp << endl;
+ // cout << "getTemperatureInit = " << para->getTemperatureInit() << endl;
+ // cout << "getTemperatureBC = " << para->getTemperatureBC() << endl;
+ // //////////////////////////////////////////////////////////////////////////
+ // para->cudaAllocTempVeloBC(i);
+ // //cout << "nach alloc " << endl;
+ // //////////////////////////////////////////////////////////////////////////
+ // for (int m = 0; m < temp2; m++)
+ // {
+ // para->getParH(i)->TempVel.temp[m] = para->getTemperatureInit();
+ // para->getParH(i)->TempVel.tempPulse[m] = para->getTemperatureBC();
+ // para->getParH(i)->TempVel.velo[m] = para->getVelocity();
+ // para->getParH(i)->TempVel.k[m] = para->getParH(i)->Qinflow.k[m];
+ // }
+ // //////////////////////////////////////////////////////////////////////////
+ // //cout << "vor copy " << endl;
+ // para->cudaCopyTempVeloBCHD(i);
+ // //cout << "nach copy " << endl;
+ // //////////////////////////////////////////////////////////////////////////
+ //}
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ }
+ }
}
void GridGenerator::setPressureValues(int channelSide) const
@@ -236,18 +287,87 @@ void GridGenerator::allocArrays_BoundaryQs()
{
std::cout << "------read BoundaryQs-------" << std::endl;
- channelBoundaryConditions = builder->getTypeOfBoundaryConditions();
+ for (int i = 0; i < builder->getNumberOfGridLevels(); i++) {
+ const int numberOfVelocityNodes = int(builder->getVelocitySize(i));
+ if (numberOfVelocityNodes > 0)
+ {
+ cout << "size velocity level " << i << " : " << numberOfVelocityNodes << endl;
+ //cout << "Groesse velocity level: " << i << " : " << temp3 << "MyID: " << para->getMyID() << endl;
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //preprocessing
+ real* QQ = para->getParH(i)->Qinflow.q27[0];
+ unsigned int sizeQ = para->getParH(i)->Qinflow.kQ;
+ QforBoundaryConditions Q;
+ Q.q27[dirE] = &QQ[dirE *sizeQ];
+ Q.q27[dirW] = &QQ[dirW *sizeQ];
+ Q.q27[dirN] = &QQ[dirN *sizeQ];
+ Q.q27[dirS] = &QQ[dirS *sizeQ];
+ Q.q27[dirT] = &QQ[dirT *sizeQ];
+ Q.q27[dirB] = &QQ[dirB *sizeQ];
+ Q.q27[dirNE] = &QQ[dirNE *sizeQ];
+ Q.q27[dirSW] = &QQ[dirSW *sizeQ];
+ Q.q27[dirSE] = &QQ[dirSE *sizeQ];
+ Q.q27[dirNW] = &QQ[dirNW *sizeQ];
+ Q.q27[dirTE] = &QQ[dirTE *sizeQ];
+ Q.q27[dirBW] = &QQ[dirBW *sizeQ];
+ Q.q27[dirBE] = &QQ[dirBE *sizeQ];
+ Q.q27[dirTW] = &QQ[dirTW *sizeQ];
+ Q.q27[dirTN] = &QQ[dirTN *sizeQ];
+ Q.q27[dirBS] = &QQ[dirBS *sizeQ];
+ Q.q27[dirBN] = &QQ[dirBN *sizeQ];
+ Q.q27[dirTS] = &QQ[dirTS *sizeQ];
+ Q.q27[dirZERO] = &QQ[dirZERO*sizeQ];
+ Q.q27[dirTNE] = &QQ[dirTNE *sizeQ];
+ Q.q27[dirTSW] = &QQ[dirTSW *sizeQ];
+ Q.q27[dirTSE] = &QQ[dirTSE *sizeQ];
+ Q.q27[dirTNW] = &QQ[dirTNW *sizeQ];
+ Q.q27[dirBNE] = &QQ[dirBNE *sizeQ];
+ Q.q27[dirBSW] = &QQ[dirBSW *sizeQ];
+ Q.q27[dirBSE] = &QQ[dirBSE *sizeQ];
+ Q.q27[dirBNW] = &QQ[dirBNW *sizeQ];
+
+ builder->getVelocityQs(Q.q27, i);
+
+ if (para->getDiffOn()) {
+ //////////////////////////////////////////////////////////////////////////
+ para->getParH(i)->TempVel.kTemp = numberOfVelocityNodes;
+ para->getParD(i)->TempVel.kTemp = numberOfVelocityNodes;
+ cout << "Groesse TempVel.kTemp = " << para->getParH(i)->TempPress.kTemp << endl;
+ cout << "getTemperatureInit = " << para->getTemperatureInit() << endl;
+ cout << "getTemperatureBC = " << para->getTemperatureBC() << endl;
+ //////////////////////////////////////////////////////////////////////////
+ para->cudaAllocTempVeloBC(i);
+ //cout << "nach alloc " << endl;
+ //////////////////////////////////////////////////////////////////////////
+ for (int m = 0; m < numberOfVelocityNodes; m++)
+ {
+ para->getParH(i)->TempVel.temp[m] = para->getTemperatureInit();
+ para->getParH(i)->TempVel.tempPulse[m] = para->getTemperatureBC();
+ para->getParH(i)->TempVel.velo[m] = para->getVelocity();
+ para->getParH(i)->TempVel.k[m] = para->getParH(i)->Qinflow.k[m];
+ }
+ //////////////////////////////////////////////////////////////////////////
+ //cout << "vor copy " << endl;
+ para->cudaCopyTempVeloBCHD(i);
+ //cout << "nach copy " << endl;
+ //////////////////////////////////////////////////////////////////////////
+ }
+ para->cudaCopyVeloBC(i);
+ }
+ }
- for (int i = 0; i < channelBoundaryConditions.size(); i++)
- {
- if (this->channelBoundaryConditions[i] == "noSlip") { setNoSlipQs(i); }
- else if (this->channelBoundaryConditions[i] == "velocity") { setVelocityQs(i); }
- else if (this->channelBoundaryConditions[i] == "pressure") { setPressQs(i); }
- else if (this->channelBoundaryConditions[i] == "outflow") { setOutflowQs(i); }
- }
+ //channelBoundaryConditions = builder->getTypeOfBoundaryConditions();
+
+ //for (int i = 0; i < channelBoundaryConditions.size(); i++)
+ //{
+ // if (this->channelBoundaryConditions[i] == "noSlip") { setNoSlipQs(i); }
+ // else if (this->channelBoundaryConditions[i] == "velocity") { setVelocityQs(i); }
+ // else if (this->channelBoundaryConditions[i] == "pressure") { setPressQs(i); }
+ // else if (this->channelBoundaryConditions[i] == "outflow") { setOutflowQs(i); }
+ //}
- if (para->getIsGeo())
- setGeoQs();
+ //if (para->getIsGeo())
+ // setGeoQs();
std::cout << "-----finish BoundaryQs------" << std::endl;
}
diff --git a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h
index 6a3df5fa4..bba2a4797 100644
--- a/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h
+++ b/src/VirtualFluids_GPU/DataStructureInitializer/GridReaderGenerator/GridGenerator.h
@@ -7,10 +7,12 @@
#include <string>
#include <memory>
-#include "LBM/LB.h"
+#include <core/DataTypes.h>
class Parameter;
class GridBuilder;
+struct QforBC;
+typedef QforBC QforBoundaryConditions;
class GridGenerator
: public GridProvider
@@ -55,12 +57,12 @@ private:
void setGeoQs() const;
void modifyQElement(int channelSide, unsigned int level) const;
- void initalQStruct(QforBoundaryConditions& Q,int channelSide, unsigned int level) const;
- void printQSize(std::string bc,int channelSide, unsigned int level) const;
- void setSizeNoSlip(int channelSide, unsigned int level) const;
- void setSizeGeoQs(unsigned int level) const;
- void setQ27Size(QforBoundaryConditions &Q, real* QQ, unsigned int sizeQ) const;
- bool hasQs(int channelSide, unsigned int level) const;
+ void initalQStruct(QforBoundaryConditions& Q, int channelSide, unsigned int level) const;
+ void printQSize(std::string bc, int channelSide, unsigned int level) const;
+ void setSizeNoSlip(int channelSide, unsigned int level) const;
+ void setSizeGeoQs(unsigned int level) const;
+ void setQ27Size(QforBoundaryConditions &Q, real* QQ, unsigned int sizeQ) const;
+ bool hasQs(int channelSide, unsigned int level) const;
public:
void initalGridInformations() override;
diff --git a/targets/apps/HULC/main.cpp b/targets/apps/HULC/main.cpp
index f1f8b2808..ba182b1ca 100644
--- a/targets/apps/HULC/main.cpp
+++ b/targets/apps/HULC/main.cpp
@@ -11,11 +11,13 @@
#include "LBM/Simulation.h"
+#include "DataStructureInitializer/GridReaderGenerator/GridGenerator.h"
+#include "grid/GridBuilder/LevelGridBuilder.h"
+
#include "Parameter/Parameter.h"
#include "DataStructureInitializer/GridProvider.h"
#include "VirtualFluidsBasics/utilities/input/Input.h"
#include "VirtualFluidsBasics/utilities/StringUtil/StringUtil.h"
-#include "grid/GridBuilder/LevelGridBuilder.h"
#include "utilities/transformator/TransformatorImp.h"
#include "io/GridVTKWriter/GridVTKWriter.h"
@@ -34,8 +36,7 @@
#include "io/STLReaderWriter/STLWriter.h"
#include "geometries/TriangularMesh/TriangularMeshStrategy.h"
#include "Output/FileWriter.h"
-#include "DataStructureInitializer/GridReaderFiles/GridReader.h"
-#include "DataStructureInitializer/GridReaderGenerator/GridGenerator.h"
+//#include "DataStructureInitializer/GridReaderFiles/GridReader.h"
std::string getGridPath(std::shared_ptr<Parameter> para, std::string Gridpath)
@@ -269,10 +270,29 @@ void multipleLevel(const std::string& configPath)
gridBuilder->addCoarseGrid(-16, -14, -14, 59, 28, 29, 1.0);
- gridBuilder->addGrid(new Cuboid(-10, -8, -8, 50, 22, 22), 1);
+
+ //gridBuilder->addGrid(new Cuboid(-10, -8, -8, 50, 22, 22), 1);
+
TriangularMesh* triangularMesh = TriangularMesh::make("D:/GRIDGENERATION/STL/input/local_input/bruecke.stl");
+
gridBuilder->addGeometry(triangularMesh);
+ SPtr<VelocityBoundaryCondition> bcVelocity1 = VelocityBoundaryCondition::make(0.01, 0.0, 0.0);
+ SPtr<VelocityBoundaryCondition> bcVelocity2 = VelocityBoundaryCondition::make(0.01, 0.0, 0.0);
+ SPtr<VelocityBoundaryCondition> bcVelocity3 = VelocityBoundaryCondition::make(0.01, 0.0, 0.0);
+ SPtr<VelocityBoundaryCondition> bcVelocity4 = VelocityBoundaryCondition::make(0.01, 0.0, 0.0);
+ SPtr<VelocityBoundaryCondition> bcVelocity5 = VelocityBoundaryCondition::make(0.01, 0.0, 0.0);
+ SPtr<VelocityBoundaryCondition> bcVelocity6 = VelocityBoundaryCondition::make(0.01, 0.0, 0.0);
+
+ gridBuilder->setVelocityBoundaryCondition(SPtr<Side>(new MX()), bcVelocity1);
+ gridBuilder->setVelocityBoundaryCondition(SPtr<Side>(new PX()), bcVelocity2);
+ gridBuilder->setVelocityBoundaryCondition(SPtr<Side>(new MY()), bcVelocity3);
+ gridBuilder->setVelocityBoundaryCondition(SPtr<Side>(new PY()), bcVelocity4);
+ gridBuilder->setVelocityBoundaryCondition(SPtr<Side>(new MZ()), bcVelocity5);
+ gridBuilder->setVelocityBoundaryCondition(SPtr<Side>(new PZ()), bcVelocity6);
+
+ //gridBuilder->setBoundaryCondition("geometry", BoundaryCondition::VELOCITY);
+
//TriangleOffsetSurfaceGeneration::createOffsetTriangularMesh(triangularMesh, 5);
@@ -296,7 +316,7 @@ void multipleLevel(const std::string& configPath)
gridBuilder->buildGrids();
- gridBuilder->writeGridsToVtk("D:/GRIDGENERATION/");
+ //gridBuilder->writeGridsToVtk("D:/GRIDGENERATION/");
--
GitLab