diff --git a/src/GridGenerator/grid/Grid.h b/src/GridGenerator/grid/Grid.h
index bf7b839489c1b47bf5903a219e6f4dc2828fe5ad..0db50ce05d1f51e63372e4056910b8b624c27986 100644
--- a/src/GridGenerator/grid/Grid.h
+++ b/src/GridGenerator/grid/Grid.h
@@ -71,7 +71,7 @@ public:
HOST virtual void allocateGridMemory() = 0;
- HOST virtual void removeOverlapNodes(SPtr<Grid> grid) = 0;
+ HOST virtual void findGridInterface(SPtr<Grid> grid) = 0;
HOST virtual void mesh(Geometry& geometry) = 0;
diff --git a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
index 233179a45027ce4cf045bfd1e4280ce225c563ab..c5b4460a0255dfa966da99152af098cef5b793ee 100644
--- a/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
+++ b/src/GridGenerator/grid/GridBuilder/LevelGridBuilder.cpp
@@ -59,7 +59,7 @@ LevelGridBuilder::LevelGridBuilder(Device device, const std::string& d3qxx) : de
// this->grids[0]->setPeriodicity(true, true, true);
// else
// grid->setPeriodicity(false, false, false);
-// this->removeOverlapNodes();
+// this->findGridInterface();
// this->grids[0]->print();
// }
//}
@@ -150,7 +150,7 @@ void LevelGridBuilder::removeOverlapNodes()
const uint numberOfLevels = getNumberOfGridLevels();
if(numberOfLevels > 1)
{
- grids[0]->removeOverlapNodes(grids[1]);
+ grids[0]->findGridInterface(grids[1]);
}
}
diff --git a/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp b/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
index 127e9ed785c737876d7e661ac15fb871f2cc3f9c..0306fcc27ad5112492a982f280fab1fca96a0700 100644
--- a/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
+++ b/src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
@@ -256,7 +256,12 @@ void MultipleGridBuilder::buildGrids()
grids[i]->setPeriodicity(false, false, false);
for(size_t i = grids.size() - 1; i > 0; i--)
- grids[i - 1]->removeOverlapNodes(grids[i]);
+ grids[i - 1]->findGridInterface(grids[i]);
+
+ //for (int i=0; i< grids[0]->getSize(); i++)
+ //{
+ // printf("type: %d\n", grids[0]->getFieldEntry(i));
+ //}
}
diff --git a/src/GridGenerator/grid/GridImp.cu b/src/GridGenerator/grid/GridImp.cu
index 7ad6d961632fefa9ed5caf24be17be68f2e8db0b..640f435a54e2ba6b995a4948d11e4024c9c0eb72 100644
--- a/src/GridGenerator/grid/GridImp.cu
+++ b/src/GridGenerator/grid/GridImp.cu
@@ -123,7 +123,7 @@ HOSTDEVICE void GridImp::findInnerNode(uint index)
if(object->isPointInObject(x, y, z, 0, 0))
{
this->setFieldEntryToFluid(index);
- this->setNeighborIndices(index);
+ //this->setNeighborIndices(index);
} else
this->setFieldEntryToOutOfGrid(index);
}
@@ -132,7 +132,7 @@ HOSTDEVICE void GridImp::findInnerNode(uint index)
HOSTDEVICE void GridImp::findStopperNode(uint index)
{
if(isEndOfGridStopper(index))
- this->setFieldEntryToSolid(index);
+ this->setFieldEntryToStopperEndOfGrid(index);
}
HOST void GridImp::mesh(Geometry &geometry)
@@ -152,16 +152,19 @@ HOST void GridImp::freeMemory()
gridStrategy->freeMemory(shared_from_this());
}
-HOST void GridImp::removeOverlapNodes(SPtr<Grid> finerGrid)
+HOST void GridImp::findGridInterface(SPtr<Grid> finerGrid)
{
- gridStrategy->createGridInterface(shared_from_this(), std::static_pointer_cast<GridImp>(finerGrid));
+ gridStrategy->findGridInterface(shared_from_this(), std::static_pointer_cast<GridImp>(finerGrid));
}
-HOSTDEVICE void GridImp::createGridInterface(uint index, const GridImp& finerGrid)
+HOSTDEVICE void GridImp::findGridInterfaceCF(uint index, const GridImp& finerGrid)
{
- gridInterface->findInterface(index, this, &finerGrid);
- //this->findGridInterface(index, finerGrid);
- //this->setOverlapNodeToInvalid(index, finerGrid);
+ gridInterface->findInterfaceCF(index, this, &finerGrid);
+}
+
+HOSTDEVICE void GridImp::findGridInterfaceFC(uint index, const GridImp& finerGrid)
+{
+ gridInterface->findInterfaceFC(index, this, &finerGrid);
}
HOSTDEVICE void GridImp::findGridInterface(uint index, const GridImp& finerGrid)
@@ -214,9 +217,15 @@ HOSTDEVICE bool GridImp::is(uint index, char type) const
return field[index] == type;
}
+HOSTDEVICE bool GridImp::isCoarseToFineNode(uint index) const
+{
+ return field[index] == FLUID_CFC;
+}
+
+
HOSTDEVICE bool GridImp::isFluid(uint index) const
{
- return field[index] == FLUID;
+ return field[index] == FLUID || field[index] == FLUID_CFC;
}
HOSTDEVICE bool GridImp::isSolid(uint index) const
@@ -234,6 +243,16 @@ HOSTDEVICE bool GridImp::isInvalid(uint index) const
return field[index] == INVALID_NODE;
}
+HOSTDEVICE bool GridImp::isStopperEndOfGrid(uint index) const
+{
+ return field[index] == STOPPER_END_OF_GRID;
+}
+
+HOSTDEVICE bool GridImp::isStopperOverlapGrid(uint index) const
+{
+ return field[index] == STOPPER_OVERLAP_GRID;
+}
+
HOSTDEVICE bool GridImp::isQ(uint index) const
{
return field[index] == Q;
@@ -254,6 +273,16 @@ HOSTDEVICE void GridImp::setFieldEntryToSolid(uint index)
this->field[index] = SOLID;
}
+HOSTDEVICE void GridImp::setFieldEntryToStopperEndOfGrid(uint index)
+{
+ this->field[index] = STOPPER_END_OF_GRID;
+}
+
+HOSTDEVICE void GridImp::setFieldEntryToStopperOverlapGrid(uint index)
+{
+ this->field[index] = STOPPER_OVERLAP_GRID;
+}
+
HOSTDEVICE void GridImp::setFieldEntryToInvalid(uint index)
{
this->field[index] = INVALID_NODE;
@@ -286,7 +315,7 @@ HOSTDEVICE int GridImp::transCoordToIndex(const Vertex &v) const
const int z = int((v.z - startZ) / delta);
#ifdef DEBUG
- if (x < 0 || y < 0 || z < 0 || uint(x) > nx || uint(y) > ny || uint(z) > nz)
+ if (x < 0 || y < 0 || z < 0 || uint(x) >= nx || uint(y) >= ny || uint(z) >= nz)
{
//printf( "Function: transCoordToIndex. Coordinates are out of range and cannot calculate the index. Exit Program!\n");
/* exit(1);*/
@@ -442,41 +471,90 @@ HOSTDEVICE bool GridImp::isNeighborInvalid(const int &index)
HOSTDEVICE void GridImp::findNeighborIndex(int index)
{
- if (this->isOverlapStopper(index) || isEndOfGridStopper(index))
+ neighborIndexX[index] = -1;
+ neighborIndexY[index] = -1;
+ neighborIndexZ[index] = -1;
+
+ if (this->isStopperEndOfGrid(index) || this->isStopperOverlapGrid(index))
{
- this->setFieldEntryToSolid(index);
this->setStopperNeighborCoords(index);
return;
}
if (this->matrixIndex[index] == -1)
- {
- this->neighborIndexX[index] = -1;
- this->neighborIndexY[index] = -1;
- this->neighborIndexZ[index] = -1;
return;
- }
real x, y, z;
this->transIndexToCoords(index, x, y, z);
real neighborXCoord, neighborYCoord, neighborZCoord;
getNeighborCoords(neighborXCoord, neighborYCoord, neighborZCoord, x, y, z);
- this->neighborIndexX[index] = getNeighborIndex(neighborXCoord, y, z);
- this->neighborIndexY[index] = getNeighborIndex(x, neighborYCoord, z);
- this->neighborIndexZ[index] = getNeighborIndex(x, y, neighborZCoord);
+ const int neighborX = getNeighborIndex(neighborXCoord, y, z);
+ const int neighborY = getNeighborIndex(x, neighborYCoord, z);
+ const int neighborZ = getNeighborIndex(x, y, neighborZCoord);
+
+ this->neighborIndexX[index] = neighborX;
+ this->neighborIndexY[index] = neighborY;
+ this->neighborIndexZ[index] = neighborZ;
}
-HOSTDEVICE bool GridImp::isEndOfGridStopper(uint index) const
+HOSTDEVICE void GridImp::setStopperNeighborCoords(int index)
{
- return this->isFluid(index) && nodeInNextCellIs(index, OUT_OF_GRID);
+ real x, y, z;
+ this->transIndexToCoords(index, x, y, z);
+
+ if (CudaMath::lessEqual(x + delta, endX + delta))
+ neighborIndexX[index] = getNeighborIndex(x + delta, y, z);
+
+ if (CudaMath::lessEqual(y + delta, endY + delta))
+ neighborIndexY[index] = getNeighborIndex(x, y + delta, z);
+
+ if (CudaMath::lessEqual(z + delta, endZ + delta))
+ neighborIndexZ[index] = getNeighborIndex(x, y, z + delta);
}
-//bool GridImp::isEndOfGridStopper(uint index) const
-//{
-// real x, y, z;
-// this->transIndexToCoords(index, x, y, z);
-// return (x > this->endX || y > this->endY || z > this->endZ);
-//}
+HOSTDEVICE void GridImp::getNeighborCoords(real &neighborX, real &neighborY, real &neighborZ, real x, real y, real z) const
+{
+ real coords[3] = { x, y, z };
+ neighborX = getNeighborCoord(periodicityX, startX, coords, 0);
+ neighborY = getNeighborCoord(periodicityY, startY, coords, 1);
+ neighborZ = getNeighborCoord(periodicityZ, startZ, coords, 2);
+}
+
+HOSTDEVICE real GridImp::getNeighborCoord(bool periodicity, real startCoord, real coords[3], int direction) const
+{
+ if (periodicity)
+ {
+ real neighborCoords[3] = {coords[0], coords[1] , coords[2] };
+ neighborCoords[direction] = neighborCoords[direction] + delta;
+ const int neighborIndex = this->transCoordToIndex(neighborCoords[0], neighborCoords[1], neighborCoords[2]);
+ if(!isStopperEndOfGrid(neighborIndex))
+ return coords[direction] + delta;
+
+ return getFirstFluidNode(coords, direction, startCoord);
+ }
+ else
+ return coords[direction] + delta;
+}
+
+
+HOSTDEVICE real GridImp::getFirstFluidNode(real coords[3], int direction, real startCoord) const
+{
+ coords[direction] = startCoord;
+ int index = this->transCoordToIndex(coords[0], coords[1], coords[2]);
+ while (isOutOfGrid(index))
+ {
+ coords[direction] += delta;
+ index = this->transCoordToIndex(coords[0], coords[1], coords[2]);
+ }
+ return coords[direction];
+}
+
+
+HOSTDEVICE bool GridImp::isEndOfGridStopper(uint index) const
+{
+ return this->is(index, OUT_OF_GRID) && nodeInPreviousCellIs(index, FLUID);
+ //return this->isFluid(index) && nodeInNextCellIs(index, OUT_OF_GRID);
+}
HOSTDEVICE bool GridImp::isOverlapStopper(uint index) const
@@ -514,6 +592,37 @@ HOSTDEVICE bool GridImp::nodeInNextCellIs(int index, char type) const
|| isInvalidNeighborXZ || isInvalidNeighborXYZ;
}
+HOSTDEVICE bool GridImp::nodeInPreviousCellIs(int index, char type) const
+{
+ real x, y, z;
+ this->transIndexToCoords(index, x, y, z);
+
+ const real neighborX = x - this->delta < startX ? startX : x - this->delta;
+ const real neighborY = y - this->delta < startY ? startY : y - this->delta;
+ const real neighborZ = z - this->delta < startZ ? startZ : z - this->delta;
+
+ const uint indexX = transCoordToIndex(neighborX, y, z);
+ const uint indexY = transCoordToIndex(x, neighborY, z);
+ const uint indexZ = transCoordToIndex(x, y, neighborZ);
+
+ const uint indexXY = transCoordToIndex(neighborX, neighborY, z);
+ const uint indexYZ = transCoordToIndex(x, neighborY, neighborZ);
+ const uint indexXZ = transCoordToIndex(neighborX, y, neighborZ);
+
+ const uint indexXYZ = transCoordToIndex(neighborX, neighborY, neighborZ);
+
+ const bool isInvalidNeighborX = this->is(indexX, type);
+ const bool isInvalidNeighborY = this->is(indexY, type);
+ const bool isInvalidNeighborXY = this->is(indexXY, type);
+ const bool isInvalidNeighborZ = this->is(indexZ, type);
+ const bool isInvalidNeighborYZ = this->is(indexYZ, type);
+ const bool isInvalidNeighborXZ = this->is(indexXZ, type);
+ const bool isInvalidNeighborXYZ = this->is(indexXYZ, type);
+
+ return isInvalidNeighborX || isInvalidNeighborY || isInvalidNeighborXY || isInvalidNeighborZ || isInvalidNeighborYZ
+ || isInvalidNeighborXZ || isInvalidNeighborXYZ;
+}
+
HOSTDEVICE int GridImp::getNeighborIndex(const real &expectedX, const real &expectedY, const real &expectedZ) const
{
const int neighborIndex = transCoordToIndex(expectedX, expectedY, expectedZ);
@@ -562,35 +671,9 @@ HOST void GridImp::removeInvalidNodes()
printf("new size nodes: %d , delete nodes: %d\n", reducedSize, removedNodes);
}
-HOSTDEVICE void GridImp::getNeighborCoords(real &neighborX, real &neighborY, real &neighborZ, real x, real y, real z) const
-{
- neighborX = getNeighhborCoord(periodicityX, x, startX, endX);
- neighborY = getNeighhborCoord(periodicityY, y, startY, endY);
- neighborZ = getNeighhborCoord(periodicityZ, z, startZ, endZ);
-}
-
-HOSTDEVICE real GridImp::getNeighhborCoord(bool periodicity, real actualCoord, real startCoord, real endCoord) const
-{
- if (periodicity)
- return CudaMath::lessEqual(actualCoord + delta, endCoord) ? actualCoord + delta : startCoord;
- else
- return actualCoord + delta;
-}
-
-HOSTDEVICE void GridImp::setStopperNeighborCoords(int index)
-{
- real x, y, z;
- this->transIndexToCoords(index, x, y, z);
- if (CudaMath::lessEqual(x + delta, endX + delta))
- neighborIndexX[index] = getNeighborIndex(x + delta, y, z);
- if (CudaMath::lessEqual(y + delta, endY + delta))
- neighborIndexY[index] = getNeighborIndex(x, y + delta, z);
- if (CudaMath::lessEqual(z + delta, endZ + delta))
- neighborIndexZ[index] = getNeighborIndex(x, y, z + delta);
-}
real GridImp::getStartX() const
{
@@ -779,7 +862,7 @@ HOST void GridImp::setNodeValues(real *xCoords, real *yCoords, real *zCoords, un
neighborX[nodeNumber + 1] = uint(this->neighborIndexX[i] + 1);
neighborY[nodeNumber + 1] = uint(this->neighborIndexY[i] + 1);
neighborZ[nodeNumber + 1] = uint(this->neighborIndexZ[i] + 1);
- geo[nodeNumber + 1] = uint(this->isSolid(i) ? GEOSOLID : GEOFLUID);
+ geo[nodeNumber + 1] = uint(this->isFluid(i) ? GEOFLUID : GEOSOLID);
nodeNumber++;
}
}
diff --git a/src/GridGenerator/grid/GridImp.cuh b/src/GridGenerator/grid/GridImp.cuh
index 3bce015e60a0c5d7eff4e5d5e4f79ead51b60ade..bb43effdd9cd92a87fd1bb8198ca1f692eafd7b8 100644
--- a/src/GridGenerator/grid/GridImp.cuh
+++ b/src/GridGenerator/grid/GridImp.cuh
@@ -66,16 +66,21 @@ public:
HOST void freeMemory();
HOST void setPeriodicity(bool periodicityX, bool periodicityY, bool periodicityZ);
- HOST void removeOverlapNodes(SPtr<Grid> grid);
-
- HOSTDEVICE void createGridInterface(uint index, const GridImp& finerGrid);
+ HOST void findGridInterface(SPtr<Grid> grid);
+ HOSTDEVICE void findGridInterfaceCF(uint index, const GridImp& finerGrid);
+ HOSTDEVICE void findGridInterfaceFC(uint index, const GridImp& finerGrid);
+ HOSTDEVICE bool isCoarseToFineNode(uint index) const;
HOSTDEVICE bool isFluid(uint index) const;
HOSTDEVICE bool isSolid(uint index) const;
HOSTDEVICE bool isQ(uint index) const;
HOSTDEVICE bool isRb(uint index) const;
HOSTDEVICE bool isInvalid(uint index) const;
+ HOSTDEVICE void setFieldEntryToStopperEndOfGrid(uint index);
+ HOSTDEVICE void setFieldEntryToStopperOverlapGrid(uint index);
+ HOSTDEVICE bool isStopperEndOfGrid(uint index) const;
+ HOSTDEVICE bool isStopperOverlapGrid(uint index) const;
HOSTDEVICE bool isOutOfGrid(uint index) const;
HOSTDEVICE bool is(uint index, char type) const;
HOSTDEVICE void setFieldEntryToFluid(uint index);
@@ -97,7 +102,6 @@ public:
/*---------------------------------------------------------------------------------*/
HOSTDEVICE void setNeighborIndices(const int &index);
HOSTDEVICE void getNeighborCoords(real &neighborX, real &neighborY, real &neighborZ, real x, real y, real z) const;
- HOSTDEVICE real getNeighhborCoord(bool periodicity, real actualCoord, real startCoord, real endCoord) const;
HOSTDEVICE void findNeighborIndex(int index);
HOSTDEVICE void findForGridInterfaceNewIndexCF(uint index);
HOSTDEVICE void findForGridInterfaceNewIndexFC(uint index);
@@ -142,9 +146,12 @@ private:
HOSTDEVICE bool isInside(uint index, const GridImp& grid) const;
HOSTDEVICE bool isOverlapStopper(uint index) const;
HOSTDEVICE bool nodeInNextCellIs(int index, char type) const;
+ HOSTDEVICE bool nodeInPreviousCellIs(int index, char type) const;
HOSTDEVICE int getNeighborIndex(const real &expectedX, const real &expectedY, const real &expectedZ) const;
HOSTDEVICE void setStopperNeighborCoords(int index);
+ HOSTDEVICE real getNeighborCoord(bool periodicity, real endCoord, real coords[3], int direction) const;
+ HOSTDEVICE real getFirstFluidNode(real coords[3], int direction, real startCoord) const;
public:
HOSTDEVICE real getStartX() const override;
diff --git a/src/GridGenerator/grid/GridInterface.cu b/src/GridGenerator/grid/GridInterface.cu
index 4c83a50d1be153b18019488976a602b802966657..ec782056c1d861d1c10e38796eddf4466d024cf4 100644
--- a/src/GridGenerator/grid/GridInterface.cu
+++ b/src/GridGenerator/grid/GridInterface.cu
@@ -22,8 +22,8 @@ void GridInterface::initalGridInterface(const GridImp* fineGrid)
void GridInterface::initalCoarseToFine(const GridImp* fineGrid)
{
- cf.coarseEntry = CFC;
- cf.fineEntry = CFF;
+ cf.coarseEntry = FLUID_CFC;
+ cf.fineEntry = FLUID_CFF;
cf.startOffset = -0.5 * fineGrid->delta;
cf.endOffset = -1.5 * fineGrid->delta;
@@ -31,8 +31,8 @@ void GridInterface::initalCoarseToFine(const GridImp* fineGrid)
void GridInterface::initalFineToCoarse(const GridImp* fineGrid)
{
- fc.coarseEntry = FCC;
- fc.fineEntry = FCF;
+ fc.coarseEntry = FLUID_FCC;
+ fc.fineEntry = FLUID_FCF;
fc.startOffset = cf.startOffset + 4 * fineGrid->delta;
fc.endOffset = cf.endOffset - 2 * fineGrid->delta;
@@ -51,7 +51,7 @@ void GridInterface::findFC(const uint& index, const GridImp* coarseGrid, const G
//findInterface(fc, -1, index, coarseGrid, fineGrid);
}
-int GridInterface::getIndexOnFineGrid(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid)
+int GridInterface::getCoarseToFineIndexOnFineGrid(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid)
{
real x, y, z;
coarseGrid->transIndexToCoords(indexOnCoarseGrid, x, y, z);
@@ -62,18 +62,54 @@ int GridInterface::getIndexOnFineGrid(const uint& indexOnCoarseGrid, const GridI
return fineGrid->transCoordToIndex(xFine, yFine, zFine);
}
-void GridInterface::findInterface(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid)
+
+
+bool GridInterface::isNeighborFineFluid(real x, real y, real z, const GridImp* coarseGrid, const GridImp* fineGrid)
+{
+ const int neighbor = coarseGrid->transCoordToIndex(x, y, z);
+ const int indexOnFineGrid = getCoarseToFineIndexOnFineGrid(neighbor, coarseGrid, fineGrid);
+ if (indexOnFineGrid == -1)
+ return false;
+ return fineGrid->isFluid(indexOnFineGrid);
+}
+
+void GridInterface::markCellTo(const GridImp* coarseGrid, uint index, char type)
+{
+ coarseGrid->field[index] = type;
+
+ real x, y, z;
+ coarseGrid->transIndexToCoords(index, x, y, z);
+
+ const int neighborX = coarseGrid->transCoordToIndex(x + coarseGrid->getDelta(), y, z);
+ const int neighborY = coarseGrid->transCoordToIndex(x, y + coarseGrid->getDelta(), z);
+ const int neighborZ = coarseGrid->transCoordToIndex(x , y, z + coarseGrid->getDelta());
+
+ coarseGrid->field[neighborX] = type;
+ coarseGrid->field[neighborY] = type;
+ coarseGrid->field[neighborZ] = type;
+
+ const int neighborYZ = coarseGrid->transCoordToIndex(x, y + coarseGrid->getDelta(), z + coarseGrid->getDelta());
+ const int neighborXZ = coarseGrid->transCoordToIndex(x + coarseGrid->getDelta(), y , z + coarseGrid->getDelta());
+ const int neighborXY = coarseGrid->transCoordToIndex(x + coarseGrid->getDelta(), y + coarseGrid->getDelta(), z);
+
+ coarseGrid->field[neighborYZ] = type;
+ coarseGrid->field[neighborXZ] = type;
+ coarseGrid->field[neighborXY] = type;
+
+ const int neighborXYZ = coarseGrid->transCoordToIndex(x + coarseGrid->getDelta(), y + coarseGrid->getDelta(), z + coarseGrid->getDelta());
+
+ coarseGrid->field[neighborXYZ] = type;
+}
+
+void GridInterface::findInterfaceCF(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid)
{
const bool nodeOnCoarseGridIsFluid = coarseGrid->isFluid(indexOnCoarseGrid);
if (!nodeOnCoarseGridIsFluid)
return;
- const int indexOnFineGridCF = getIndexOnFineGrid(indexOnCoarseGrid, coarseGrid, fineGrid);
+ const int indexOnFineGridCF = getCoarseToFineIndexOnFineGrid(indexOnCoarseGrid, coarseGrid, fineGrid);
if (indexOnFineGridCF == -1)
return;
- //const int matrixIndexOnFineGrid = fineGrid->matrixIndex[indexOnFineGrid];
- //if (matrixIndexOnFineGrid == -1)
- // return;
const bool fineGridNodeIsFluid = fineGrid->isFluid(indexOnFineGridCF);
if (!fineGridNodeIsFluid)
@@ -82,60 +118,98 @@ void GridInterface::findInterface(const uint& indexOnCoarseGrid, const GridImp*
real x, y, z;
coarseGrid->transIndexToCoords(indexOnCoarseGrid, x, y, z);
- bool fineGridNodeIsFluidX = false;
- bool fineGridNodeIsFluidX2 = false;
- bool fineGridNodeIsFluidY = false;
- bool fineGridNodeIsFluidY2 = false;
- bool fineGridNodeIsFluidZ = false;
- bool fineGridNodeIsFluidZ2 = false;
-
- const int xNeighbor = coarseGrid->transCoordToIndex(x + coarseGrid->delta, y, z);
- int indexOnFineGrid = getIndexOnFineGrid(xNeighbor, coarseGrid, fineGrid);
- if (indexOnFineGrid != -1) {
- fineGridNodeIsFluidX = fineGrid->isFluid(indexOnFineGrid);
- }
+ const bool fineGridNodeIsFluidX = isNeighborFineFluid(x + coarseGrid->delta, y, z, coarseGrid, fineGrid);
+ const bool fineGridNodeIsFluidX2 = isNeighborFineFluid(x - coarseGrid->delta, y, z, coarseGrid, fineGrid);
+ const bool fineGridNodeIsFluidY = isNeighborFineFluid(x, y + coarseGrid->delta, z, coarseGrid, fineGrid);
+ const bool fineGridNodeIsFluidY2 = isNeighborFineFluid(x, y - coarseGrid->delta, z, coarseGrid, fineGrid);
+ const bool fineGridNodeIsFluidZ = isNeighborFineFluid(x, y, z + coarseGrid->delta, coarseGrid, fineGrid);
+ const bool fineGridNodeIsFluidZ2 = isNeighborFineFluid(x, y, z - coarseGrid->delta, coarseGrid, fineGrid);
- const int xNeighbor2 = coarseGrid->transCoordToIndex(x - coarseGrid->delta, y, z);
- indexOnFineGrid = getIndexOnFineGrid(xNeighbor2, coarseGrid, fineGrid);
- if (indexOnFineGrid != -1) {
- fineGridNodeIsFluidX2 = fineGrid->isFluid(indexOnFineGrid);
- }
+ if (!fineGridNodeIsFluidX || !fineGridNodeIsFluidX2 || !fineGridNodeIsFluidY || !fineGridNodeIsFluidY2 || !fineGridNodeIsFluidZ || !fineGridNodeIsFluidZ2) {
+ cf.coarse[cf.numberOfEntries] = indexOnCoarseGrid;
+ cf.fine[cf.numberOfEntries] = indexOnFineGridCF;
- const int yNeighbor = coarseGrid->transCoordToIndex(x, y + coarseGrid->delta, z);
- indexOnFineGrid = getIndexOnFineGrid(yNeighbor, coarseGrid, fineGrid);
- if (indexOnFineGrid != -1) {
- fineGridNodeIsFluidY = fineGrid->isFluid(indexOnFineGrid);
- }
+ cf.numberOfEntries++;
- const int yNeighbor2 = coarseGrid->transCoordToIndex(x, y - coarseGrid->delta, z);
- indexOnFineGrid = getIndexOnFineGrid(yNeighbor2, coarseGrid, fineGrid);
- if (indexOnFineGrid != -1) {
- fineGridNodeIsFluidY2 = fineGrid->isFluid(indexOnFineGrid);
- }
+ this->markCellTo(coarseGrid, indexOnCoarseGrid, cf.coarseEntry);
- const int zNeighbor = coarseGrid->transCoordToIndex(x, y, z + coarseGrid->delta);
- indexOnFineGrid = getIndexOnFineGrid(zNeighbor, coarseGrid, fineGrid);
- if (indexOnFineGrid != -1) {
- fineGridNodeIsFluidZ = fineGrid->isFluid(indexOnFineGrid);
+ //fineGrid->field[indexOnFineGridCF] = cf.fineEntry;
}
+}
- const int zNeighbor2 = coarseGrid->transCoordToIndex(x, y, z - coarseGrid->delta);
- indexOnFineGrid = getIndexOnFineGrid(zNeighbor2, coarseGrid, fineGrid);
- if (indexOnFineGrid != -1) {
- fineGridNodeIsFluidZ2 = fineGrid->isFluid(indexOnFineGrid);
- }
+HOSTDEVICE void GridInterface::findInterfaceFC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, const GridImp* fineGrid)
+{
+ const bool nodeOnCoarseGridIsFluid = coarseGrid->isFluid(indexOnCoarseGrid);
+ const bool nodeOnCoarseGridIsCoarseToFine = coarseGrid->isCoarseToFineNode(indexOnCoarseGrid);
+ if (!nodeOnCoarseGridIsFluid || nodeOnCoarseGridIsCoarseToFine)
+ return;
- if (!fineGridNodeIsFluidX || !fineGridNodeIsFluidX2 || !fineGridNodeIsFluidY || !fineGridNodeIsFluidY2 || !fineGridNodeIsFluidZ || !fineGridNodeIsFluidZ2) {
- cf.coarse[cf.numberOfEntries] = indexOnCoarseGrid;
- cf.fine[cf.numberOfEntries] = fineGrid->matrixIndex[indexOnFineGridCF];
+ const int indexOnFineGridFC = getFineToCoarseIndexOnFineGrid(indexOnCoarseGrid, coarseGrid, fineGrid);
+ if (indexOnFineGridFC == -1)
+ return;
- cf.numberOfEntries++;
+ const bool fineGridNodeIsFluid = fineGrid->isFluid(indexOnFineGridFC);
+ if (!fineGridNodeIsFluid)
+ return;
+
+ real x, y, z;
+ coarseGrid->transIndexToCoords(indexOnCoarseGrid, x, y, z);
+
+ const bool neighborBelongsToCoarseToFineInterpolationCellX = belongsNeighborToCoarseToFineInterpolationCell(x + coarseGrid->delta, y, z, coarseGrid, fineGrid);
+ const bool neighborBelongsToCoarseToFineInterpolationCellX2 = belongsNeighborToCoarseToFineInterpolationCell(x - coarseGrid->delta, y, z, coarseGrid, fineGrid);
+ const bool neighborBelongsToCoarseToFineInterpolationCellY = belongsNeighborToCoarseToFineInterpolationCell(x, y + coarseGrid->delta, z, coarseGrid, fineGrid);
+ const bool neighborBelongsToCoarseToFineInterpolationCellY2 = belongsNeighborToCoarseToFineInterpolationCell(x, y - coarseGrid->delta, z, coarseGrid, fineGrid);
+ const bool neighborBelongsToCoarseToFineInterpolationCellZ = belongsNeighborToCoarseToFineInterpolationCell(x, y, z + coarseGrid->delta, coarseGrid, fineGrid);
+ const bool neighborBelongsToCoarseToFineInterpolationCellZ2 = belongsNeighborToCoarseToFineInterpolationCell(x, y, z - coarseGrid->delta, coarseGrid, fineGrid);
+
+ const bool secondNeighborBelongsToCoarseToFineInterpolationCellX2 = belongsNeighborToCoarseToFineInterpolationCell(x - 2 * coarseGrid->delta, y, z, coarseGrid, fineGrid);
+ const bool secondNeighborBelongsToCoarseToFineInterpolationCellY2 = belongsNeighborToCoarseToFineInterpolationCell(x, y - 2 * coarseGrid->delta, z, coarseGrid, fineGrid);
+ const bool secondNeighborBelongsToCoarseToFineInterpolationCellZ2 = belongsNeighborToCoarseToFineInterpolationCell(x, y, z - 2 * coarseGrid->delta, coarseGrid, fineGrid);
+
+ if (neighborBelongsToCoarseToFineInterpolationCellX ||
+ neighborBelongsToCoarseToFineInterpolationCellX2 ||
+ neighborBelongsToCoarseToFineInterpolationCellY ||
+ neighborBelongsToCoarseToFineInterpolationCellY2 ||
+ neighborBelongsToCoarseToFineInterpolationCellZ ||
+ neighborBelongsToCoarseToFineInterpolationCellZ2)
+ {
+ fc.coarse[fc.numberOfEntries] = indexOnCoarseGrid;
+ fc.fine[fc.numberOfEntries] = indexOnFineGridFC;
+
+ fc.numberOfEntries++;
+
+ //this->markCellTo(coarseGrid, indexOnCoarseGrid, cf.coarseEntry);
- //coarseGrid->field[indexOnCoarseGrid] = cf.coarseEntry;
//fineGrid->field[indexOnFineGridCF] = cf.fineEntry;
+ } else if( // isStopper
+ secondNeighborBelongsToCoarseToFineInterpolationCellX2 ||
+ secondNeighborBelongsToCoarseToFineInterpolationCellY2 ||
+ secondNeighborBelongsToCoarseToFineInterpolationCellZ2)
+ {
+ coarseGrid->setFieldEntryToStopperOverlapGrid(indexOnCoarseGrid);
+ }
+ else //should be inside of fine grid and can be deleted
+ {
+ coarseGrid->setFieldEntryToInvalid(indexOnCoarseGrid);
}
}
+int GridInterface::getFineToCoarseIndexOnFineGrid(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid)
+{
+ real x, y, z;
+ coarseGrid->transIndexToCoords(indexOnCoarseGrid, x, y, z);
+ const real xFine = x - (fineGrid->delta * 0.5);
+ const real yFine = y - (fineGrid->delta * 0.5);
+ const real zFine = z - (fineGrid->delta * 0.5);
+
+ return fineGrid->transCoordToIndex(xFine, yFine, zFine);
+}
+
+bool GridInterface::belongsNeighborToCoarseToFineInterpolationCell(real x, real y, real z, const GridImp* coarseGrid, const GridImp* fineGrid)
+{
+ const int neighborIndex = coarseGrid->transCoordToIndex(x, y, z);
+ return coarseGrid->isCoarseToFineNode(neighborIndex);
+}
//void GridInterface::findInterface(Interface& gridInterface, const int& factor, const uint& index, const GridImp* coarseGrid, const GridImp* fineGrid)
//{
diff --git a/src/GridGenerator/grid/GridInterface.cuh b/src/GridGenerator/grid/GridInterface.cuh
index 7c4fbeba4032c7675daab2c1887ee7049a1f4e38..04efc1173adf6d06d0e964579fa57e35fb634ef2 100644
--- a/src/GridGenerator/grid/GridInterface.cuh
+++ b/src/GridGenerator/grid/GridInterface.cuh
@@ -17,13 +17,13 @@ public:
HOSTDEVICE void initalGridInterface(const GridImp* fineGrid);
- HOSTDEVICE void VF_PUBLIC findInterface(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid);
+ HOSTDEVICE void VF_PUBLIC findInterfaceCF(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid);
+ HOSTDEVICE void VF_PUBLIC findInterfaceFC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, const GridImp* fineGrid);
HOSTDEVICE void VF_PUBLIC findCF(const uint& index, const GridImp* coarseGrid, const GridImp* fineGrid);
HOSTDEVICE void VF_PUBLIC findFC(const uint& index, const GridImp* coarseGrid, const GridImp* fineGrid);
- HOSTDEVICE int getIndexOnFineGrid(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid);
- HOSTDEVICE void VF_PUBLIC print() const;
+ HOSTDEVICE void VF_PUBLIC print() const;
struct Interface
{
@@ -40,7 +40,13 @@ public:
private:
HOSTDEVICE void initalCoarseToFine(const GridImp* fineGrid);
HOSTDEVICE void initalFineToCoarse(const GridImp* fineGrid);
-
+
+ HOSTDEVICE int getCoarseToFineIndexOnFineGrid(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid);
+ HOSTDEVICE bool isNeighborFineFluid(real x, real y, real z, const GridImp* coarseGrid, const GridImp* fineGrid);
+ HOSTDEVICE void markCellTo(const GridImp* coarseGrid, uint index, char type);
+
+ HOSTDEVICE int getFineToCoarseIndexOnFineGrid(const uint& indexOnCoarseGrid, const GridImp* coarseGrid, const GridImp* fineGrid);
+ HOSTDEVICE bool belongsNeighborToCoarseToFineInterpolationCell(real x, real y, real z, const GridImp* coarseGrid, const GridImp* fineGrid);
//HOSTDEVICE static void findInterface(Interface& gridInterface, const int& factor, const uint& index,
// const GridImp* coarseGrid, const GridImp* fineGrid);
diff --git a/src/GridGenerator/grid/GridMocks.h b/src/GridGenerator/grid/GridMocks.h
index 46ca17d4ec88011a940226026486252e50e34b5d..1ee3eafeeacc2d12bfbe0dd2e87aa078a2afa8c5 100644
--- a/src/GridGenerator/grid/GridMocks.h
+++ b/src/GridGenerator/grid/GridMocks.h
@@ -60,7 +60,7 @@ public:
virtual void setEndX(real endX) override {}
virtual void setEndY(real endY) override {}
virtual void setEndZ(real endZ) override {}
- virtual void removeOverlapNodes(SPtr<Grid> grid) override {}
+ virtual void findGridInterface(SPtr<Grid> grid) override {}
virtual void mesh(Geometry& geometry) override {}
virtual int transCoordToIndex(const Vertex& v) const override { return 0; }
virtual int transCoordToIndex(const real& x, const real& y, const real& z) const override { return 0; }
@@ -135,7 +135,7 @@ public:
this->periodicityZ = periodicityZ;
}
- virtual void removeOverlapNodes(SPtr<Grid> grid) override
+ virtual void findGridInterface(SPtr<Grid> grid) override
{
_hasGridInterface = true;
}
diff --git a/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp b/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
index 750ecce889ee257803444082285340f8fdb4919f..271d9fd815fd1976e49f8b7aa8b85e7fe9d09e3b 100644
--- a/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
+++ b/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.cpp
@@ -40,9 +40,9 @@ void GridCpuStrategy::initalNodes(SPtr<GridImp> grid)
for (uint index = 0; index < grid->size; index++)
grid->findInnerNode(index);
-//#pragma omp parallel for
-// for (uint index = 0; index < grid->size; index++)
-// grid->findStopperNode(index);
+#pragma omp parallel for
+ for (uint index = 0; index < grid->size; index++)
+ grid->findStopperNode(index);
grid->removeInvalidNodes();
findForNeighborsNewIndices(grid);
@@ -55,7 +55,7 @@ void GridCpuStrategy::mesh(SPtr<GridImp> grid, Geometry &geom)
grid->meshTriangle(geom.triangles[i]);
}
-void GridCpuStrategy::createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid)
+void GridCpuStrategy::findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid)
{
grid->gridInterface = new GridInterface();
const uint sizeCF = fineGrid->nx * fineGrid->ny + fineGrid->ny * fineGrid->nz + fineGrid->nx * fineGrid->nz;
@@ -65,17 +65,18 @@ void GridCpuStrategy::createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fine
grid->gridInterface->fc.fine = new uint[sizeCF];
grid->gridInterface->initalGridInterface(fineGrid.get());
- findGridInterface(grid, fineGrid);
+ for (uint index = 0; index < grid->getSize(); index++)
+ grid->findGridInterfaceCF(index, *fineGrid);
+
+ for (uint index = 0; index < grid->getSize(); index++)
+ grid->findGridInterfaceFC(index, *fineGrid);
+
grid->removeInvalidNodes();
findForNeighborsNewIndices(grid);
findForGridInterfaceNewIndices(grid);
}
-void GridCpuStrategy::findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> finerGrid)
-{
- for (uint index = 0; index < grid->getSize(); index++)
- grid->createGridInterface(index, *finerGrid.get());
-}
+
void GridCpuStrategy::findForNeighborsNewIndices(SPtr<GridImp> grid)
{
diff --git a/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h b/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
index a5146ef0c9ed85c60165ef98ff583d83dbd4d52b..285a23ce61cd156275d5eb04ee2ac92c06b2e107 100644
--- a/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
+++ b/src/GridGenerator/grid/GridStrategy/GridCpuStrategy/GridCpuStrategy.h
@@ -21,7 +21,7 @@ public:
void initalNodes(SPtr<GridImp> grid) override;
void mesh(SPtr<GridImp> grid, Geometry &geom) override;
- void createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> finerGrid) override;
+ void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid) override;
void freeMemory(SPtr<GridImp> grid) override;
@@ -35,7 +35,6 @@ protected:
static void findForNeighborsNewIndices(SPtr<GridImp> grid);
static void findForGridInterfaceNewIndices(SPtr<GridImp> grid);
- static void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> finerGrid);
};
diff --git a/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp b/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
index 9ff5a3976133d329e5ed03cc3a38f305c74fbf3a..68b9f89eccf479a4e1244c73f7b6295401943a2c 100644
--- a/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
+++ b/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.cpp
@@ -50,7 +50,7 @@ void GridGpuStrategy::mesh(SPtr<GridImp> grid, Geometry &geom)
}
-void GridGpuStrategy::createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid)
+void GridGpuStrategy::findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid)
{
copyAndFreeFieldFromGPU(grid);
copyAndFreeFieldFromGPU(fineGrid);
@@ -66,7 +66,7 @@ void GridGpuStrategy::createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fine
grid->gridInterface->initalGridInterface(fineGrid.get());
for (uint index = 0; index < grid->getSize(); index++)
- grid->createGridInterface(index, *fineGrid.get());
+ grid->findGridInterface(index, *fineGrid.get());
uint *cfc;
uint *cff;
diff --git a/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h b/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
index e8b6089186781f9054bbbf4f8e431c9a03bda6cf..9922ca7ed71a26cf472c255db041fbd99f1cae5f 100644
--- a/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
+++ b/src/GridGenerator/grid/GridStrategy/GridGpuStrategy/GridGpuStrategy.h
@@ -19,7 +19,7 @@ public:
void initalNodes(SPtr<GridImp> grid) override;
void mesh(SPtr<GridImp> grid, Geometry &geom) override;
- void createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid) override;
+ void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> fineGrid) override;
void freeMemory(SPtr<GridImp> grid) override;
diff --git a/src/GridGenerator/grid/GridStrategy/GridStrategy.h b/src/GridGenerator/grid/GridStrategy/GridStrategy.h
index c65dd3fd4e366764ae7c996de969847beeb69dc3..8fad4304946418c93fc3dd26053da2fb3e05f084 100644
--- a/src/GridGenerator/grid/GridStrategy/GridStrategy.h
+++ b/src/GridGenerator/grid/GridStrategy/GridStrategy.h
@@ -18,7 +18,7 @@ public:
virtual void initalNodes(SPtr<GridImp> grid) = 0;
virtual void mesh(SPtr<GridImp> grid, Geometry &geom) = 0;
- virtual void createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> finerGrid) = 0;
+ virtual void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> finerGrid) = 0;
virtual void deleteSolidNodes(SPtr<GridImp> grid) = 0;
diff --git a/src/GridGenerator/grid/GridStrategy/GridStrategyMocks.h b/src/GridGenerator/grid/GridStrategy/GridStrategyMocks.h
index 12a1e6a7f44b9a7cd38cc8862b2f3bca66bea158..fbed515332e646d73103d3dfde656d053ba2870c 100644
--- a/src/GridGenerator/grid/GridStrategy/GridStrategyMocks.h
+++ b/src/GridGenerator/grid/GridStrategy/GridStrategyMocks.h
@@ -19,7 +19,7 @@ public:
virtual void initalNodes(SPtr<GridImp> grid) override {};
virtual void mesh(SPtr<GridImp> grid, Geometry &geom) override {};
- virtual void createGridInterface(SPtr<GridImp> grid, SPtr<GridImp> finerGrid) override {};
+ virtual void findGridInterface(SPtr<GridImp> grid, SPtr<GridImp> finerGrid) override {};
virtual void deleteSolidNodes(SPtr<GridImp> grid) override {};
diff --git a/src/GridGenerator/grid/NodeValues.h b/src/GridGenerator/grid/NodeValues.h
index 970d2cf0114ced81b96ea919ad275c9c46defbbc..6b7be51134c4176f73538280441592f7e6f7acad 100644
--- a/src/GridGenerator/grid/NodeValues.h
+++ b/src/GridGenerator/grid/NodeValues.h
@@ -5,21 +5,28 @@
#define FLUID 0
#define SOLID 1
-#define Q 6
+#define STOPPER_OVERLAP_GRID 2
+#define STOPPER_END_OF_GRID 3
-#define NOSLIP 2
-#define PRESSURE 3
-#define VELOCITY 4
#define OUT_OF_GRID 98
#define INVALID_NODE 99
-#define CFC 66
-#define CFF 67
+#define FLUID_CFC 66
+#define FLUID_CFF 67
+
+#define FLUID_FCC 77
+#define FLUID_FCF 78
+
+
+#define Q 6
+#define NOSLIP 2
+#define PRESSURE 3
+#define VELOCITY 4
+
+
-#define FCC 77
-#define FCF 78
#define RB_INLET PRESSURE
#define RB_OUTLET PRESSURE
diff --git a/src/GridGenerator/grid/kernel/runGridKernelGPU.cu b/src/GridGenerator/grid/kernel/runGridKernelGPU.cu
index 2bcca3b2fbd17f609979ec7c1a660cc164a403aa..3a77d9f3b1b2626c293a3d75f49042e6f45bfbd2 100644
--- a/src/GridGenerator/grid/kernel/runGridKernelGPU.cu
+++ b/src/GridGenerator/grid/kernel/runGridKernelGPU.cu
@@ -86,7 +86,7 @@ GLOBAL void setOverlapNodesToInvalid(GridImp grid, GridImp finerGrid)
{
const uint index = LaunchParameter::getGlobalIdx_2D_1D();
if (index < grid.getSize())
- grid.createGridInterface(index, finerGrid);
+ grid.findGridInterfaceCF(index, finerGrid);
}
@@ -171,7 +171,7 @@ GLOBAL void findGridInterface(GridImp grid, GridImp finerGrid)
{
unsigned int index = LaunchParameter::getGlobalIdx_2D_1D();
if (index < grid.getSize())
- grid.createGridInterface(index, finerGrid);
+ grid.findGridInterfaceCF(index, finerGrid);
}
/*#################################################################################*/
diff --git a/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp b/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp
index 4a45d0ebbfb32fc281dfe0fca628a1a991ac8f84..89e3506c726795540e0e70c1b9ca92aaa595d7c6 100644
--- a/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp
+++ b/src/GridGenerator/io/GridVTKWriter/GridVTKWriter.cpp
@@ -79,7 +79,7 @@ void GridVTKWriter::writeGridToVTKXML(SPtr<Grid> grid, const std::string name, b
&& (NET = nodeNumbers(xTranslate + 1, yTranslate + 1, zTranslate + 1)) >= 0
&& (NWT = nodeNumbers(xTranslate, yTranslate + 1, zTranslate + 1)) >= 0)
{
- if(grid->getIndex(grid->transCoordToIndex(x, y, z)) == -1)
+ if(grid->getIndex(grid->transCoordToIndex(x, y, z)) == -1 || grid->getFieldEntry(grid->transCoordToIndex(x, y, z)) == 2)
continue;
cells.push_back(makeUbTuple(SWB, SEB, NEB, NWB, SWT, SET, NET, NWT));
}
@@ -115,8 +115,8 @@ void GridVTKWriter::writeVtkFile(std::shared_ptr<const Transformator> trans, SPt
{
GridVTKWriter::writeHeader();
GridVTKWriter::writePoints(trans, grid);
- GridVTKWriter::writeCells(grid->getReducedSize());
- GridVTKWriter::writeTypeHeader(grid->getReducedSize());
+ GridVTKWriter::writeCells(grid->getSize());
+ GridVTKWriter::writeTypeHeader(grid->getSize());
GridVTKWriter::writeTypes(grid);
GridVTKWriter::closeFile();
@@ -149,12 +149,12 @@ void GridVTKWriter::writeHeader()
void GridVTKWriter::writePoints(std::shared_ptr<const Transformator> trans, SPtr<Grid> grid)
{
- fprintf(file, "POINTS %d float\n", grid->getReducedSize());
+ fprintf(file, "POINTS %d float\n", grid->getSize());
real x, y, z;
for (unsigned int i = 0; i < grid->getSize(); i++) {
- if (grid->getIndex(i) == -1)
- continue;
+ /*if (grid->getIndex(i) == -1)
+ continue;*/
grid->transIndexToCoords(i, x, y, z);
Vertex v(x,y,z);
@@ -205,8 +205,8 @@ void GridVTKWriter::writeTypes(SPtr<Grid> grid)
{
for (unsigned int i = 0; i < grid->getSize(); i++)
{
- if (grid->getIndex(i) == -1)
- continue;
+ /*if (grid->getIndex(i) == -1)
+ continue;*/
if (binaer)
write_int(grid->getFieldEntry(i));
diff --git a/src/VirtualFluids_GPU/LBM/Simulation.cpp b/src/VirtualFluids_GPU/LBM/Simulation.cpp
index 1df792302d423dcd596a630a852cac80c8437975..1f46ab424733bd6672587768379417f8950d26e0 100644
--- a/src/VirtualFluids_GPU/LBM/Simulation.cpp
+++ b/src/VirtualFluids_GPU/LBM/Simulation.cpp
@@ -321,7 +321,8 @@ void Simulation::init(SPtr<Parameter> para, SPtr<GridProvider> gridProvider)
//////////////////////////////////////////////////////////////////////////
output << "Print files Init...";
writeInit(para);
- if (para->getCalcParticle()) copyAndPrintParticles(para.get(), 0, true);
+ if (para->getCalcParticle())
+ copyAndPrintParticles(para.get(), 0, true);
output << "done.\n";
//////////////////////////////////////////////////////////////////////////
diff --git a/src/VirtualFluids_GPU/Output/WriteData.cpp b/src/VirtualFluids_GPU/Output/WriteData.cpp
index 9dbe96283715ee047e0c6e34289896714c0100fd..89c54e94a37ba0ebbfa4a62a7bb387be15cce80f 100644
--- a/src/VirtualFluids_GPU/Output/WriteData.cpp
+++ b/src/VirtualFluids_GPU/Output/WriteData.cpp
@@ -89,15 +89,15 @@ void writeInit(SPtr<Parameter> para)
}
//Debug
- //InterfaceDebugWriter::writeInterfaceLinesDebugCF(para.get());
- //InterfaceDebugWriter::writeInterfaceLinesDebugFC(para.get());
- //InterfaceDebugWriter::writeInterfaceLinesDebugCFCneighbor(para.get());
- //InterfaceDebugWriter::writeInterfaceLinesDebugCFFneighbor(para.get());
- //InterfaceDebugWriter::writeInterfaceLinesDebugFCCneighbor(para.get());
- //InterfaceDebugWriter::writeInterfaceLinesDebugFCFneighbor(para.get());
- //InterfaceDebugWriter::writeNeighborXLinesDebug(para);
- //InterfaceDebugWriter::writeNeighborYLinesDebug(para);
- //InterfaceDebugWriter::writeNeighborZLinesDebug(para);
+ InterfaceDebugWriter::writeInterfaceLinesDebugCF(para.get());
+ InterfaceDebugWriter::writeInterfaceLinesDebugFC(para.get());
+ InterfaceDebugWriter::writeInterfaceLinesDebugCFCneighbor(para.get());
+ InterfaceDebugWriter::writeInterfaceLinesDebugCFFneighbor(para.get());
+ InterfaceDebugWriter::writeInterfaceLinesDebugFCCneighbor(para.get());
+ InterfaceDebugWriter::writeInterfaceLinesDebugFCFneighbor(para.get());
+ InterfaceDebugWriter::writeNeighborXLinesDebug(para.get());
+ InterfaceDebugWriter::writeNeighborYLinesDebug(para.get());
+ InterfaceDebugWriter::writeNeighborZLinesDebug(para.get());
//if (para->getParH(lev)->QGeom.kQ > 0)
//{
diff --git a/targets/apps/HULC/main.cpp b/targets/apps/HULC/main.cpp
index 39a0acf71954705cbc20d574d8060ee99dcad3b0..9b7196b534a482fe8732812f683e574d0b5c838c 100644
--- a/targets/apps/HULC/main.cpp
+++ b/targets/apps/HULC/main.cpp
@@ -245,8 +245,9 @@ void multipleLevel(const std::string& configPath)
gridFactory->setGrid("grid");
//auto gridBuilderlevel = LevelGridBuilder::makeShared(Device::CPU, "D3Q27");
auto gridBuilder = MultipleGridBuilder::makeShared(gridFactory);
- gridBuilder->addCoarseGrid(0.0, 0.0, 0.0, 35.0, 35.0, 35.0, 1.0);
- gridBuilder->addGrid(new Sphere(15, 15, 15, 4));
+ gridBuilder->addCoarseGrid(0.0, 0.0, 0.0, 40.0, 40.0, 40.0, 1.0);
+ //gridBuilder->addGrid(new Sphere(20, 20, 20, 8));
+ gridBuilder->addGrid(new Cuboid(15,15,15,25,25,25));
//gridBuilder->addFineGrid(17.0, 17.0, 17.0, 20.0, 20.0, 20.0, 3);
//gridBuilder->addFineGrid(10.0, 10.0, 10.0, 20.0, 20.0, 20.0, 3);
@@ -258,6 +259,7 @@ void multipleLevel(const std::string& configPath)
gridBuilder->writeGridToVTK("D:/GRIDGENERATION/gridTestSphere_level_0", 0);
gridBuilder->writeGridToVTK("D:/GRIDGENERATION/gridTestSphere_level_1", 1);
+ //SimulationFileWriter::write("D:/GRIDGENERATION/couplingVF/TGV_float/simu/", gridBuilder, FILEFORMAT::ASCII);
//const uint level = 2;
//gridBuilder->addFineGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, level);
@@ -274,7 +276,6 @@ void multipleLevel(const std::string& configPath)
//gridBuilder->copyDataFromGpu();
- //SimulationFileWriter::write("D:/GRIDGENERATION/couplingVF/periodicTaylorThreeLevel/simu/", gridBuilder, FILEFORMAT::ASCII);
//gridBuilder->meshGeometry("D:/GRIDGENERATION/STL/circleBinaer.stl", 1);
//gridBuilder->meshGeometry("D:/GRIDGENERATION/STL/circleBinaer.stl", 0);