diff --git a/apps/gpu/RotatingGrid/RotatingGrid.cpp b/apps/gpu/RotatingGrid/RotatingGrid.cpp
index f418745204a2508b1423b4484894b925af4001f9..7279caf1a18a2770a1fb930a89e5b306bced34f3 100644
--- a/apps/gpu/RotatingGrid/RotatingGrid.cpp
+++ b/apps/gpu/RotatingGrid/RotatingGrid.cpp
@@ -76,8 +76,11 @@ int main()
//////////////////////////////////////////////////////////////////////////
// Simulation parameters
//////////////////////////////////////////////////////////////////////////
- std::string path("./output/RotatingGrid");
- std::string simulationName("RotatingGrid");
+ enum RotationOrInterpolation {Rot, Int};
+ const RotationOrInterpolation rotOrInt = Rot;
+
+ const std::string path("./output/RotatingGrid");
+ const std::string simulationName = rotOrInt == Int ? "RotatingGridInterpolationTest" : "RotatingGrid";
const real L = 1.0;
const real Re = 2000.0;
@@ -104,7 +107,9 @@ int main()
gridBuilder->addCoarseGrid(-0.5 * L, -0.5 * L, -1.5 * L, 0.5 * L, 0.5 * L, 1.5 * L, dx);
- gridBuilder->addGridRotatingGrid(std::make_shared<VerticalCylinder>(0.0, 0.0, 0.0, 0.25 * L, 0.5 * L));
+ if (rotOrInt == Rot) gridBuilder->addGridRotatingGrid(std::make_shared<VerticalCylinder>(0.0, 0.0, 0.0, 0.3 * L, 1. * L));
+ if (rotOrInt == Int) gridBuilder->addGrid(std::make_shared<VerticalCylinder>(0.0, 0.0, 0.0, 0.3 * L, 1. * L), 1);
+
GridScalingFactory scalingFactory = GridScalingFactory();
scalingFactory.setScalingFactory(GridScalingFactory::GridScaling::ScaleCompressible);
@@ -192,10 +197,11 @@ int main()
Simulation sim(para, cudaMemoryManager, communicator, *gridGenerator, &bcFactory, &scalingFactory);
- // gridBuilder->writeGridsToVtk(para->getOutputPath() + "grid");
+ const std::string gridName = rotOrInt == Rot ? "rot_grid" : "rot";
+ gridBuilder->writeGridsToVtk(para->getOutputPath() + gridName);
// NeighborDebugWriter::writeNeighborLinkLinesDebug(para.get());
- sim.run();
+ // sim.run();
} catch (const spdlog::spdlog_ex &ex) {
std::cout << "Log initialization failed: " << ex.what() << std::endl;
diff --git a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp
index 5019f2a7547c509df6b7afd034cae179356c74ec..102fb258bcc7c5d46e88b3a33c11488b728fc267 100644
--- a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp
+++ b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp
@@ -116,3 +116,13 @@ void VerticalCylinder::scale(double delta)
this->radius += delta;
this->height += delta;
}
+
+double VerticalCylinder::getRadius() const
+{
+ return radius;
+}
+
+double VerticalCylinder::getHeight() const
+{
+ return height;
+}
\ No newline at end of file
diff --git a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
index 64cdecef5824388a31a4f545c85b1194d3f4c77b..8e4fae42ba4b18be725f8b7abe06b0fbffc417f7 100644
--- a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
+++ b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
@@ -55,6 +55,9 @@ public:
double getX3Minimum() override;
double getX3Maximum() override;
+ double getRadius() const;
+ double getHeight() const;
+
bool isPointInObject(const double& x1, const double& x2, const double& x3, const double& minOffset, const double& maxOffset) override;
diff --git a/src/gpu/GridGenerator/grid/Field.cpp b/src/gpu/GridGenerator/grid/Field.cpp
index 8e68bfdf7e324a13a4c9d31d493580e56a48b6cd..6f622c0bb756339010ef4d1508079564a444fd22 100644
--- a/src/gpu/GridGenerator/grid/Field.cpp
+++ b/src/gpu/GridGenerator/grid/Field.cpp
@@ -76,6 +76,11 @@ bool Field::isCoarseToFineNode(uint index) const
return field[index] == FLUID_CFC;
}
+bool Field::isInterpolationGapNode(uint index) const
+{
+ return field[index] == INTERPOLATION_GAP;
+}
+
bool Field::isFineToCoarseNode(uint index) const
{
return field[index] == FLUID_FCC;
diff --git a/src/gpu/GridGenerator/grid/Field.h b/src/gpu/GridGenerator/grid/Field.h
index bb25b0fc03537b05eaadfa5c3d161f83c1267fae..b001f1f6e798c997c50c93689c51c1438da8ab23 100644
--- a/src/gpu/GridGenerator/grid/Field.h
+++ b/src/gpu/GridGenerator/grid/Field.h
@@ -51,6 +51,7 @@ public:
bool is(uint index, char type) const;
bool isCoarseToFineNode(uint index) const;
bool isFineToCoarseNode(uint index) const;
+ bool isInterpolationGapNode(uint index) const;
bool isFluid(uint index) const;
bool isInvalidSolid(uint index) const;
bool isQ(uint index) const;
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
index 10171598762e9f9378febd4334910012f11c248c..78b879ea84e88e4382dfae36943bfda2696a8fb3 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
@@ -105,7 +105,13 @@ void MultipleGridBuilder::addGridRotatingGrid(SPtr<VerticalCylinder> cylinder)
{
if (!coarseGridExists()) return emitNoCoarseGridExistsWarning();
- const auto grid = makeRotatingGrid(std::move(cylinder), getNumberOfLevels(), 0);
+ const uint level = getNumberOfLevels();
+ const uint levelFine = 1;
+
+ VF_LOG_WARNING("Make rotating Grid... {}, {}", level, levelFine);
+ const auto grid = makeRotatingGrid(std::move(cylinder), level, levelFine);
+
+ // grid->setNumberOfLayers(this->numberOfLayersFine);
if (!isGridInCoarseGrid(grid)) return emitGridIsNotInCoarseGridWarning();
@@ -118,6 +124,7 @@ void MultipleGridBuilder::addGrid(SPtr<Object> gridShape, uint levelFine)
if (!coarseGridExists()) return emitNoCoarseGridExistsWarning();
for (uint level = this->getNumberOfLevels(); level <= levelFine; level++) {
+ VF_LOG_WARNING("Make Grid... {}, {}", level, levelFine);
const auto grid = makeGrid(gridShape, level, levelFine);
if (level != levelFine) {
@@ -218,6 +225,14 @@ SPtr<Grid> MultipleGridBuilder::makeGrid(SPtr<Object> gridShape, uint level, uin
const auto staggeredCoordinates = getStaggeredCoordinates(gridShape, level, levelFine, xOddStart, yOddStart, zOddStart);
+ VF_LOG_WARNING("Object Size x : {}, {} \n z: {}, {}", gridShape->getX1Minimum(), gridShape->getX1Maximum(), gridShape->getX3Minimum(), gridShape->getX3Maximum());
+ VF_LOG_WARNING("MakeGrid {}, {}, {}, {}, {}, {}, delta: {}, level: {}", staggeredCoordinates[0],
+ staggeredCoordinates[1],
+ staggeredCoordinates[2],
+ staggeredCoordinates[3],
+ staggeredCoordinates[4],
+ staggeredCoordinates[5], delta, level);
+
SPtr<Grid> newGrid = this->makeGrid(gridShape, staggeredCoordinates[0],
staggeredCoordinates[1],
staggeredCoordinates[2],
@@ -225,12 +240,13 @@ SPtr<Grid> MultipleGridBuilder::makeGrid(SPtr<Object> gridShape, uint level, uin
staggeredCoordinates[4],
staggeredCoordinates[5], delta, level);
+ VF_LOG_WARNING("oddStart, {} {} {}", xOddStart, yOddStart, zOddStart);
newGrid->setOddStart(xOddStart, yOddStart, zOddStart);
return newGrid;
}
-SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<Object> gridShape, uint level, uint levelFine)
+SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<VerticalCylinder> cylinder, uint level, uint levelFine)
{
boundaryConditions.push_back(std::make_shared<BoundaryConditions>());
@@ -238,15 +254,28 @@ SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<Object> gridShape, uint le
bool xOddStart = false, yOddStart = false, zOddStart = false;
- const auto staggeredCoordinates =
- getStaggeredCoordinates(gridShape, level, levelFine, xOddStart, yOddStart, zOddStart, { 0.5, 0.5, 0.5 });
+ const std::array<double, 3> staggeringRelative = { 0.5, 0.5, 0.5 };
- SPtr<Grid> newGrid = this->makeGrid(gridShape, staggeredCoordinates[0],
- staggeredCoordinates[1],
- staggeredCoordinates[2],
- staggeredCoordinates[3],
- staggeredCoordinates[4],
- staggeredCoordinates[5], delta, level);
+ const auto staggeredCoordinates =
+ getStaggeredCoordinates(cylinder, level, levelFine, xOddStart, yOddStart, zOddStart, staggeringRelative, true);
+
+ VF_LOG_WARNING("RotGr: Cylinder Size x : {}, {} \n z: {}, {}", cylinder->getX1Minimum(), cylinder->getX1Maximum(), cylinder->getX3Minimum(), cylinder->getX3Maximum());
+ VF_LOG_WARNING("RotGr: MakeGrid {}, {}, {}, {}, {}, {}, delta: {}, level: {}", staggeredCoordinates[0],
+ staggeredCoordinates[1],
+ staggeredCoordinates[2],
+ staggeredCoordinates[3],
+ staggeredCoordinates[4],
+ staggeredCoordinates[5], delta, level);
+
+ cylinder = std::make_shared<VerticalCylinder>(cylinder->getX1Centroid(), cylinder->getX2Centroid(), cylinder->getX3Centroid(), cylinder->getRadius()+5*delta, cylinder->getHeight()+6*delta);
+ VF_LOG_WARNING("RotGr: LargerCylinder Size x : {}, {} \n z: {}, {}", cylinder->getX1Minimum(), cylinder->getX1Maximum(), cylinder->getX3Minimum(), cylinder->getX3Maximum());
+
+ SPtr<Grid> newGrid = this->makeGrid(cylinder, staggeredCoordinates[0],
+ staggeredCoordinates[1],
+ staggeredCoordinates[2],
+ staggeredCoordinates[3],
+ staggeredCoordinates[4],
+ staggeredCoordinates[5], delta, level);
newGrid->setOddStart(xOddStart, yOddStart, zOddStart);
@@ -261,7 +290,10 @@ real MultipleGridBuilder::calculateDelta(uint level) const
return delta;
}
-std::array<real, 6> MultipleGridBuilder::getStaggeredCoordinates(SPtr<Object> gridShape, uint level, uint levelFine, bool& xOddStart, bool& yOddStart, bool& zOddStart, std::array<double, 3> relativeStagger) const
+std::array<real, 6> MultipleGridBuilder::getStaggeredCoordinates(SPtr<Object> gridShape, uint level, uint levelFine,
+ bool &xOddStart, bool &yOddStart, bool &zOddStart,
+ const std::array<double, 3> &relativeStagger,
+ bool gridIsForRotation) const
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
@@ -286,9 +318,12 @@ std::array<real, 6> MultipleGridBuilder::getStaggeredCoordinates(SPtr<Object> gr
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- const real deltaCoarse = this->grids[level-1]->getDelta();
- const real delta = 0.5 * deltaCoarse;
+ const real deltaCoarse = this->grids[level - 1]->getDelta();
+ const real delta = gridIsForRotation ? deltaCoarse : 0.5 * deltaCoarse;
+ VF_LOG_WARNING("getStaggeredCoordinates: create grid for rotation {}: ", gridIsForRotation);
+ VF_LOG_WARNING("delta = {}", delta);
+ VF_LOG_WARNING("level={}, levelFine={}", levelFine, levelFine);
std::array<real, 6> staggeredCoordinates;
@@ -373,6 +408,7 @@ std::array<real, 6> MultipleGridBuilder::getStaggeredCoordinates(SPtr<Object> gr
while (staggeredCoordinates[4] > this->grids[level - 1]->getEndY() ) staggeredCoordinates[4] -= delta;
while (staggeredCoordinates[5] > this->grids[level - 1]->getEndZ() ) staggeredCoordinates[5] -= delta;
+ VF_LOG_WARNING("end of getStaggeredCoordinates()");
return staggeredCoordinates;
}
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
index 839d9b24e645e40e9d92acf8f5d94d1b641e4ca1..1b496db6dba7b7f8b7b800317a2205b8107a0694 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
@@ -85,7 +85,7 @@ public:
protected:
virtual SPtr<Grid> makeGrid(SPtr<Object> gridShape, uint level, uint levelFine);
virtual SPtr<Grid> makeGrid(SPtr<Object> gridShape, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, uint level) const;
- virtual SPtr<Grid> makeRotatingGrid(SPtr<Object> gridShape, uint level, uint levelFine);
+ virtual SPtr<Grid> makeRotatingGrid(SPtr<VerticalCylinder> cylinder, uint level, uint levelFine);
private:
void addGridToList(SPtr<Grid> grid);
@@ -100,7 +100,7 @@ private:
std::array<real, 6> getStaggeredCoordinates(SPtr<Object> gridShape, uint level, uint levelFine, bool &xOddStart,
bool &yOddStart, bool &zOddStart,
- std::array<double, 3> relativeStagger = { 0.25, 0.25, 0.25 }) const;
+ const std::array<double, 3> &relativeStagger = { 0.25, 0.25, 0.25 }, bool gridIsForRotation = false) const;
std::array<real, 6> getStaggeredCoordinates(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, uint level) const;
std::array<real, 3> getOffset(real delta) const;
std::vector<uint> getSpacingFactors(uint levelDifference) const;
diff --git a/src/gpu/GridGenerator/grid/GridImp.cpp b/src/gpu/GridGenerator/grid/GridImp.cpp
index 8ece061168883544d9857f109d505614ca005a43..a0f5c3de053e52df21922c1a234c36087dd908c1 100644
--- a/src/gpu/GridGenerator/grid/GridImp.cpp
+++ b/src/gpu/GridGenerator/grid/GridImp.cpp
@@ -1105,15 +1105,15 @@ int GridImp::getSparseIndex(const real &x, const real &y, const real &z) const
// --------------------------------------------------------- //
void GridImp::findGridInterface(SPtr<Grid> finerGrid)
{
- auto fineGrid = std::static_pointer_cast<GridImp>(finerGrid);
+ auto fineGridImp = std::static_pointer_cast<GridImp>(finerGrid);
const auto coarseLevel = this->getLevel();
- const auto fineLevel = fineGrid->getLevel();
+ const auto fineLevel = fineGridImp->getLevel();
VF_LOG_TRACE("find interface level {} -> {}", coarseLevel, fineLevel);
this->gridInterface = new GridInterface();
// TODO: this is stupid! concave refinements can easily have many more interface cells
- const uint sizeCF = 10 * (fineGrid->nx * fineGrid->ny + fineGrid->ny * fineGrid->nz + fineGrid->nx * fineGrid->nz);
+ const uint sizeCF = 10 * (fineGridImp->nx * fineGridImp->ny + fineGridImp->ny * fineGridImp->nz + fineGridImp->nx * fineGridImp->nz);
this->gridInterface->cf.coarse = new uint[sizeCF];
this->gridInterface->cf.fine = new uint[sizeCF];
this->gridInterface->cf.offset = new uint[sizeCF];
@@ -1122,13 +1122,29 @@ void GridImp::findGridInterface(SPtr<Grid> finerGrid)
this->gridInterface->fc.offset = new uint[sizeCF];
for (uint index = 0; index < this->getSize(); index++)
- this->findGridInterfaceCF(index, *fineGrid);
+ this->findGridInterfaceCF(index, *fineGridImp);
+
+ for (uint index = 0; index < this->getSize(); index++){
+ gridInterface->findInterpolationGapC(index, this, fineGridImp.get());
+ }
+
+ for (uint fineIndex; fineIndex < fineGridImp->getSize(); fineIndex++)
+ gridInterface->findInterpolationGapF(fineIndex, fineGridImp.get());
+
+ for (uint index = 0; index < this->getSize(); index++){
+ gridInterface->findInterfaceFCwithGap(index, this, fineGridImp.get());
+ }
for (uint index = 0; index < this->getSize(); index++)
- this->findGridInterfaceFC(index, *fineGrid);
+ this->findOverlapStopper(index, *fineGridImp);
for (uint index = 0; index < this->getSize(); index++)
- this->findOverlapStopper(index, *fineGrid);
+ if (this->getField().isInterpolationGapNode(index))
+ this->getField().setFieldEntry(index, FLUID);
+
+ for (uint fineIndex = 0; fineIndex < fineGridImp->getSize(); fineIndex++)
+ if (fineGridImp->getField().isInterpolationGapNode(fineIndex))
+ fineGridImp->getField().setFieldEntry(fineIndex, FLUID);
VF_LOG_TRACE(" ... done.");
}
diff --git a/src/gpu/GridGenerator/grid/GridInterface.cpp b/src/gpu/GridGenerator/grid/GridInterface.cpp
index 4b69cebd16d4c529e4889b84ff881d4ed660f124..ce4522f553087d22c1827a718999d4b65fac794d 100644
--- a/src/gpu/GridGenerator/grid/GridInterface.cpp
+++ b/src/gpu/GridGenerator/grid/GridInterface.cpp
@@ -84,7 +84,8 @@ void GridInterface::findInterfaceCF(const uint& indexOnCoarseGrid, GridImp* coar
cf.numberOfEntries++;
coarseGrid->setNonStopperOutOfGridCellTo(indexOnCoarseGrid, FLUID_CFC);
- fineGrid->setNonStopperOutOfGridCellTo(indexOnFineGridCF, FLUID_CFF);
+ // fineGrid->setNonStopperOutOfGridCellTo(indexOnFineGridCF, FLUID_CFF);
+ fineGrid->getField().setFieldEntry(indexOnFineGridCF, FLUID_CFF);
break;
}
}
@@ -119,13 +120,13 @@ void GridInterface::findBoundaryGridInterfaceCF(const uint& indexOnCoarseGrid, G
cf.numberOfEntries++;
coarseGrid->setNonStopperOutOfGridCellTo(indexOnCoarseGrid, FLUID_CFC);
- fineGrid->setNonStopperOutOfGridCellTo(indexOnFineGridCF, FLUID_CFF);
+ fineGrid->getField().setFieldEntry(indexOnFineGridCF, FLUID_CFF);
+
break;
}
}
}
-
void GridInterface::findInterfaceFC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid)
{
const bool nodeOnCoarseGridIsFluid = coarseGrid->getField().isFluid(indexOnCoarseGrid);
@@ -165,6 +166,113 @@ void GridInterface::findInterfaceFC(const uint& indexOnCoarseGrid, GridImp* coar
}
}
+void GridInterface::findInterfaceFCwithGap(uint indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid)
+{
+ const bool nodeOnCoarseGridIsFluid = coarseGrid->getField().isFluid(indexOnCoarseGrid);
+ const bool nodeOnCoarseGridIsCoarseToFine = coarseGrid->getField().isCoarseToFineNode(indexOnCoarseGrid);
+ if (!nodeOnCoarseGridIsFluid || nodeOnCoarseGridIsCoarseToFine)
+ return;
+
+ const uint indexOnFineGridFC = getFineToCoarseIndexOnFineGrid(indexOnCoarseGrid, coarseGrid, fineGrid);
+ // if (indexOnFineGridFC == INVALID_INDEX)
+ // return;
+
+ // const bool fineGridNodeIsFluid = fineGrid->getField().isFluid(indexOnFineGridFC);
+ // if (!fineGridNodeIsFluid)
+ // return;
+
+ real x, y, z;
+ coarseGrid->transIndexToCoords(indexOnCoarseGrid, x, y, z);
+
+ for (const auto dir : coarseGrid->distribution)
+ {
+ const uint neighborIndex = coarseGrid->transCoordToIndex(
+ x + dir[0] * coarseGrid->getDelta(), y + dir[1] * coarseGrid->getDelta(), z + dir[2] * coarseGrid->getDelta());
+ if (neighborIndex != INVALID_INDEX)
+ {
+ const bool neighborIsInterpolationGapNode = coarseGrid->getField().isInterpolationGapNode(neighborIndex);
+ if (neighborIsInterpolationGapNode)
+ {
+ fc.coarse[fc.numberOfEntries] = indexOnCoarseGrid;
+ fc.fine[fc.numberOfEntries] = this->findOffsetFC(indexOnFineGridFC, fineGrid, fc.numberOfEntries);
+
+ fc.numberOfEntries++;
+
+ fineGrid->setNonStopperOutOfGridCellTo(indexOnFineGridFC, FLUID_FCF);
+ coarseGrid->getField().setFieldEntry(indexOnCoarseGrid, FLUID_FCC);
+ break;
+ }
+ }
+ }
+}
+
+void GridInterface::findInterpolationGapC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid)
+{
+ const bool nodeOnCoarseGridIsFluid = coarseGrid->getField().isFluid(indexOnCoarseGrid);
+ const bool nodeOnCoarseGridIsCoarseToFine = coarseGrid->getField().isCoarseToFineNode(indexOnCoarseGrid);
+ if (!nodeOnCoarseGridIsFluid || nodeOnCoarseGridIsCoarseToFine)
+ return;
+
+ const uint indexOnFineGridFC = getFineToCoarseIndexOnFineGrid(indexOnCoarseGrid, coarseGrid, fineGrid);
+ if (indexOnFineGridFC == INVALID_INDEX)
+ return;
+
+ const bool fineGridNodeIsFluid = fineGrid->getField().isFluid(indexOnFineGridFC);
+ if (!fineGridNodeIsFluid)
+ return;
+
+ real x, y, z;
+ coarseGrid->transIndexToCoords(indexOnCoarseGrid, x, y, z);
+
+ for (const auto dir : coarseGrid->distribution)
+ {
+ const uint neighborIndex = coarseGrid->transCoordToIndex(
+ x + dir[0] * coarseGrid->getDelta(), y + dir[1] * coarseGrid->getDelta(), z + dir[2] * coarseGrid->getDelta());
+ if (neighborIndex != INVALID_INDEX)
+ {
+ const bool neighborBelongsToCoarseToFineInterpolationCell = coarseGrid->getField().isCoarseToFineNode(neighborIndex);
+ if (neighborBelongsToCoarseToFineInterpolationCell)
+ {
+ // fc.coarse[fc.numberOfEntries] = indexOnCoarseGrid;
+ // fc.fine[fc.numberOfEntries] = this->findOffsetFC(indexOnFineGridFC, fineGrid, fc.numberOfEntries);
+
+ // fc.numberOfEntries++;
+
+ // fineGrid->setNonStopperOutOfGridCellTo(indexOnFineGridFC, INTERPOLATION_GAP);
+ // fineGrid->getField().setFieldEntry(indexOnFineGridFC, INTERPOLATION_GAP);
+ coarseGrid->getField().setFieldEntry(indexOnCoarseGrid, INTERPOLATION_GAP);
+ break;
+ }
+ }
+ }
+}
+
+void GridInterface::findInterpolationGapF(const uint& indexOnFineGrid, GridImp* fineGrid)
+{
+ const bool nodeIsFluid = fineGrid->getField().isFluid(indexOnFineGrid);
+ const bool nodeIsCoarseToFine = fineGrid->getField().is(indexOnFineGrid, FLUID_CFF);
+ if (!nodeIsFluid || nodeIsCoarseToFine)
+ return;
+
+ real x, y, z;
+ fineGrid->transIndexToCoords(indexOnFineGrid, x, y, z);
+
+ for (const auto dir : fineGrid->distribution)
+ {
+ const uint neighborIndex = fineGrid->transCoordToIndex(
+ x + dir[0] * fineGrid->getDelta(), y + dir[1] * fineGrid->getDelta(), z + dir[2] * fineGrid->getDelta());
+ if (neighborIndex != INVALID_INDEX)
+ {
+ const bool neighborIsToCoarseToFine = fineGrid->getField().is(neighborIndex, FLUID_CFF);
+ if (neighborIsToCoarseToFine)
+ {
+ fineGrid->getField().setFieldEntry(indexOnFineGrid, INTERPOLATION_GAP);
+ break;
+ }
+ }
+ }
+}
+
void GridInterface::findOverlapStopper(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid)
{
const bool nodeOnCoarseGridIsFluid = coarseGrid->getField().isFluid(indexOnCoarseGrid);
diff --git a/src/gpu/GridGenerator/grid/GridInterface.h b/src/gpu/GridGenerator/grid/GridInterface.h
index ae90f513de436324e982a8ac34db7bb1a07f908d..cbb2215aaa04dff8d22d04f4423515fc34fce1b2 100644
--- a/src/gpu/GridGenerator/grid/GridInterface.h
+++ b/src/gpu/GridGenerator/grid/GridInterface.h
@@ -49,6 +49,12 @@ public:
void GRIDGENERATOR_EXPORT findInterfaceFC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
void GRIDGENERATOR_EXPORT findOverlapStopper(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+ void GRIDGENERATOR_EXPORT findInterpolationGapC(const uint& indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+ void GRIDGENERATOR_EXPORT findInterpolationGapF(const uint& indexOnFineGrid, GridImp* fineGrid);
+ void GRIDGENERATOR_EXPORT findInterfaceFCwithGap(uint indexOnCoarseGrid, GridImp* coarseGrid, GridImp* fineGrid);
+
+
+
void GRIDGENERATOR_EXPORT findInvalidBoundaryNodes(const uint& indexOnCoarseGrid, GridImp* coarseGrid);
void GRIDGENERATOR_EXPORT findForGridInterfaceSparseIndexCF(GridImp* coarseGrid, GridImp* fineGrid, uint index);
diff --git a/src/gpu/GridGenerator/grid/NodeValues.h b/src/gpu/GridGenerator/grid/NodeValues.h
index f1a948cd9a84d1d2454c37c9a23a25639f598e75..9796d657ff2df291590eeb18de74a5f917eb0c0c 100644
--- a/src/gpu/GridGenerator/grid/NodeValues.h
+++ b/src/gpu/GridGenerator/grid/NodeValues.h
@@ -44,6 +44,8 @@ static constexpr char FLUID_CFF = 2;
static constexpr char FLUID_FCC = 3;
static constexpr char FLUID_FCF = 4;
+static constexpr char INTERPOLATION_GAP = 5;
+
static constexpr char MULTI_GPU_SEND = 10;
static constexpr char MULTI_GPU_RECIEVE = 11;