diff --git a/apps/gpu/RotatingGrid/RotatingGrid.cpp b/apps/gpu/RotatingGrid/RotatingGrid.cpp
index 43df5652b9c7190a19313697824aaedf06509761..f418745204a2508b1423b4484894b925af4001f9 100644
--- a/apps/gpu/RotatingGrid/RotatingGrid.cpp
+++ b/apps/gpu/RotatingGrid/RotatingGrid.cpp
@@ -85,7 +85,7 @@ int main()
const real velocityLB = 0.05; // LB units
const uint nx = 64;
- const uint timeStepOut = 1000;
+ const uint timeStepOut = 10000;
const uint timeStepEnd = 10000;
//////////////////////////////////////////////////////////////////////////
@@ -104,7 +104,7 @@ int main()
gridBuilder->addCoarseGrid(-0.5 * L, -0.5 * L, -1.5 * L, 0.5 * L, 0.5 * L, 1.5 * L, dx);
- gridBuilder->addGridWithSameDeltaAsPreviousGrid(std::make_shared<VerticalCylinder>(0.0, 0.0, 0.0, 0.25 * L, 0.5 * L));
+ gridBuilder->addGridRotatingGrid(std::make_shared<VerticalCylinder>(0.0, 0.0, 0.0, 0.25 * L, 0.5 * L));
GridScalingFactory scalingFactory = GridScalingFactory();
scalingFactory.setScalingFactory(GridScalingFactory::GridScaling::ScaleCompressible);
@@ -195,7 +195,7 @@ int main()
// gridBuilder->writeGridsToVtk(para->getOutputPath() + "grid");
// 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/grid/GridBuilder/MultipleGridBuilder.cpp b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
index c5b016f5921a6caa8969dc7dbceafeaca4f6a41f..10171598762e9f9378febd4334910012f11c248c 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
@@ -45,6 +45,7 @@
#include "grid/BoundaryConditions/Side.h"
#include "grid/Grid.h"
#include "grid/GridFactory.h"
+#include "geometries/VerticalCylinder/VerticalCylinder.h"
#include "io/GridVTKWriter/GridVTKWriter.h"
#include "io/STLReaderWriter/STLWriter.h"
@@ -100,14 +101,16 @@ void MultipleGridBuilder::addGrid(SPtr<Object> gridShape)
addGridToListIfValid(grid);
}
-void MultipleGridBuilder::addGridWithSameDeltaAsPreviousGrid(SPtr<Object> gridShape)
+void MultipleGridBuilder::addGridRotatingGrid(SPtr<VerticalCylinder> cylinder)
{
- if (!coarseGridExists())
- return emitNoCoarseGridExistsWarning();
+ if (!coarseGridExists()) return emitNoCoarseGridExistsWarning();
- const auto grid = makeGrid(std::move(gridShape), getNumberOfLevels(), 0, grids.back()->getDelta());
+ const auto grid = makeRotatingGrid(std::move(cylinder), getNumberOfLevels(), 0);
- addGridToListIfValid(grid);
+ if (!isGridInCoarseGrid(grid)) return emitGridIsNotInCoarseGridWarning();
+
+ rotatingGrid = grid;
+ addGridToList(grid);
}
void MultipleGridBuilder::addGrid(SPtr<Object> gridShape, uint levelFine)
@@ -205,15 +208,38 @@ bool MultipleGridBuilder::coarseGridExists() const
return !grids.empty();
}
-SPtr<Grid> MultipleGridBuilder::makeGrid(SPtr<Object> gridShape, uint level, uint levelFine, std::optional<real> deltaPredefined)
+SPtr<Grid> MultipleGridBuilder::makeGrid(SPtr<Object> gridShape, uint level, uint levelFine)
+{
+ boundaryConditions.push_back(std::make_shared<BoundaryConditions>());
+
+ const real delta = calculateDelta(level);
+
+ bool xOddStart = false, yOddStart = false, zOddStart = false;
+
+ const auto staggeredCoordinates = getStaggeredCoordinates(gridShape, level, levelFine, xOddStart, yOddStart, zOddStart);
+
+ SPtr<Grid> newGrid = this->makeGrid(gridShape, staggeredCoordinates[0],
+ staggeredCoordinates[1],
+ staggeredCoordinates[2],
+ staggeredCoordinates[3],
+ staggeredCoordinates[4],
+ staggeredCoordinates[5], delta, level);
+
+ newGrid->setOddStart(xOddStart, yOddStart, zOddStart);
+
+ return newGrid;
+}
+
+SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<Object> gridShape, uint level, uint levelFine)
{
boundaryConditions.push_back(std::make_shared<BoundaryConditions>());
- const real delta = deltaPredefined ? deltaPredefined.value() : calculateDelta(level);
+ const real delta = grids.back()->getDelta();
bool xOddStart = false, yOddStart = false, zOddStart = false;
- auto staggeredCoordinates = getStaggeredCoordinates(gridShape, level, levelFine, xOddStart, yOddStart, zOddStart);
+ const auto staggeredCoordinates =
+ getStaggeredCoordinates(gridShape, level, levelFine, xOddStart, yOddStart, zOddStart, { 0.5, 0.5, 0.5 });
SPtr<Grid> newGrid = this->makeGrid(gridShape, staggeredCoordinates[0],
staggeredCoordinates[1],
@@ -222,7 +248,7 @@ SPtr<Grid> MultipleGridBuilder::makeGrid(SPtr<Object> gridShape, uint level, uin
staggeredCoordinates[4],
staggeredCoordinates[5], delta, level);
- newGrid->setOddStart( xOddStart, yOddStart, zOddStart );
+ newGrid->setOddStart(xOddStart, yOddStart, zOddStart);
return newGrid;
}
@@ -235,7 +261,7 @@ 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) const
+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
{
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
@@ -282,7 +308,7 @@ std::array<real, 6> MultipleGridBuilder::getStaggeredCoordinates(SPtr<Object> gr
// use geometric series to account for overlap of higher levels:
// overlap + overlap/2 + overlap/4 + ...
- overlap *= 2.0 * ( 1.0 - pow(0.5, levelFine - level ) );
+ overlap *= 2.0 * ( 1.0 - pow(0.5, levelFine - level) );
}
// add overlap for finest level
@@ -316,12 +342,12 @@ std::array<real, 6> MultipleGridBuilder::getStaggeredCoordinates(SPtr<Object> gr
// Step 3
// make the grid staggered with one layer of stopper nodes on the outside
- staggeredCoordinates[0] -= 0.25 * deltaCoarse;
- staggeredCoordinates[1] -= 0.25 * deltaCoarse;
- staggeredCoordinates[2] -= 0.25 * deltaCoarse;
- staggeredCoordinates[3] += 0.25 * deltaCoarse;
- staggeredCoordinates[4] += 0.25 * deltaCoarse;
- staggeredCoordinates[5] += 0.25 * deltaCoarse;
+ staggeredCoordinates[0] -= relativeStagger[0] * deltaCoarse;
+ staggeredCoordinates[1] -= relativeStagger[1] * deltaCoarse;
+ staggeredCoordinates[2] -= relativeStagger[2] * deltaCoarse;
+ staggeredCoordinates[3] += relativeStagger[0] * deltaCoarse;
+ staggeredCoordinates[4] += relativeStagger[1] * deltaCoarse;
+ staggeredCoordinates[5] += relativeStagger[2] * deltaCoarse;
// Step 4
// add two layers until the refinement region is completely inside the fine grid
@@ -641,3 +667,7 @@ GRIDGENERATOR_EXPORT void MultipleGridBuilder::setSubDomainBox(SPtr<BoundingBox>
this->subDomainBox = subDomainBox;
}
+GRIDGENERATOR_EXPORT SPtr<Grid> MultipleGridBuilder::getRotatingGrid()
+{
+ return rotatingGrid;
+}
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
index b35be07a85fe690fd27baf6b4fb151766dd4949a..839d9b24e645e40e9d92acf8f5d94d1b641e4ca1 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h
@@ -45,6 +45,7 @@
class Object;
class BoundingBox;
+class VerticalCylinder;
class MultipleGridBuilder : public LevelGridBuilder
{
@@ -53,7 +54,7 @@ public:
GRIDGENERATOR_EXPORT void addCoarseGrid(real startX, real startY, real startZ, real endX, real endY, real endZ, real delta);
GRIDGENERATOR_EXPORT void addGrid(SPtr<Object> gridShape);
- GRIDGENERATOR_EXPORT void addGridWithSameDeltaAsPreviousGrid(SPtr<Object> gridShape);
+ GRIDGENERATOR_EXPORT void addGridRotatingGrid(SPtr<VerticalCylinder> cylinder);
GRIDGENERATOR_EXPORT void addGrid(SPtr<Object> gridShape, uint levelFine);
GRIDGENERATOR_EXPORT void addGeometry(SPtr<Object> gridShape);
@@ -70,15 +71,22 @@ public:
GRIDGENERATOR_EXPORT real getEndY(uint level) const;
GRIDGENERATOR_EXPORT real getEndZ(uint level) const;
- GRIDGENERATOR_EXPORT std::vector<SPtr<Grid> > getGrids() const;
+ GRIDGENERATOR_EXPORT std::vector<SPtr<Grid>> getGrids() const;
GRIDGENERATOR_EXPORT void buildGrids(bool enableThinWalls = false);
- GRIDGENERATOR_EXPORT void setNumberOfLayers( uint numberOfLayersFine, uint numberOfLayersBetweenLevels );
+ GRIDGENERATOR_EXPORT void setNumberOfLayers(uint numberOfLayersFine, uint numberOfLayersBetweenLevels);
GRIDGENERATOR_EXPORT void writeGridsToVtk(const std::string &path) const;
GRIDGENERATOR_EXPORT void setSubDomainBox(SPtr<BoundingBox> subDomainBox);
+ GRIDGENERATOR_EXPORT SPtr<Grid> getRotatingGrid();
+
+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);
+
private:
void addGridToList(SPtr<Grid> grid);
real calculateDelta(uint level) const;
@@ -86,18 +94,17 @@ private:
bool isGridInCoarseGrid(SPtr<Grid> grid) const;
void addFineGridToList(uint level, SPtr<Object> gridShape);
- void addIntermediateGridsToList(uint levelDifference, uint levelFine, uint nodesBetweenGrids, SPtr<Object>gridShape);
+ void addIntermediateGridsToList(uint levelDifference, uint levelFine, uint nodesBetweenGrids, SPtr<Object> gridShape);
void eraseGridsFromListIfInvalid(uint oldSize);
void addGridToListIfValid(SPtr<Grid> grid);
- std::array<real, 6> getStaggeredCoordinates(SPtr<Object> gridShape, uint level, uint levelFine, bool &xOddStart, bool &yOddStart, bool &zOddStart) const;
+ 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;
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;
- SPtr<Grid> makeGrid(SPtr<Object> gridShape, uint level, uint levelFine, std::optional<real> deltaPredefined = std::nullopt);
- SPtr<Grid> makeGrid(SPtr<Object> gridShape, real startX, real startY, real startZ, real endX, real endY, real endZ, real delta, uint level) const;
-
static void emitNoCoarseGridExistsWarning();
static void emitGridIsNotInCoarseGridWarning();
@@ -107,6 +114,8 @@ private:
uint numberOfLayersFine;
uint numberOfLayersBetweenLevels;
+ SPtr<Grid> rotatingGrid = nullptr;
+
SPtr<BoundingBox> subDomainBox;
public:
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilderTest.cpp b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilderTest.cpp
index 52625feda12f1249df6ec17392fe006b6effeffb..7632edec4a576a93012ee6d865b196feaa3abf76 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilderTest.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilderTest.cpp
@@ -1,19 +1,26 @@
#include "basics/tests/testUtilities.h"
-#include "geometries/Sphere/Sphere.h"
+#include "geometries/VerticalCylinder/VerticalCylinder.h"
#include "grid/GridBuilder/MultipleGridBuilder.h"
+class MultipleGridBuilderForTest: public MultipleGridBuilder{
+public:
+ using MultipleGridBuilder::makeGrid;
+ using MultipleGridBuilder::makeRotatingGrid;
+};
+
class MultipleGridBuilderTestFixture : public testing::Test
{
protected:
- MultipleGridBuilder gridBuilder;
- SPtr<Object> gridShape;
+ MultipleGridBuilderForTest gridBuilder;
+ SPtr<VerticalCylinder> cylinder;
real delta = 0.1;
public:
void SetUp() override
{
- gridShape = std::make_shared<Sphere>(0.0, 0.0, 0.0, 0.0);
- gridBuilder.addCoarseGrid(0.0, 0.0, 0.0, 1.0, 1.0, 1.0, delta);
+ cylinder = std::make_shared<VerticalCylinder>(0.0, 0.0, 0.0, 2.0, 8.0);
+ gridBuilder.addCoarseGrid(-10. + 0.5 * delta, -10. + 0.5 * delta, -10. + 0.5 * delta, 10. - 0.5 * delta,
+ 10. - 0.5 * delta, 10. - 0.5 * delta, delta);
}
};
@@ -25,34 +32,34 @@ TEST_F(MultipleGridBuilderTestFixture, addCoarseGrid_addsOneGridToGridList)
TEST(MultipleGridBuilderTest, noCoarseGrid_addGrid_warns)
{
MultipleGridBuilder gridBuilder;
- SPtr<Object> gridShape;
+ SPtr<Object> cylinder;
testingVF::captureStdOut();
- gridBuilder.addGrid(gridShape, 1);
+ gridBuilder.addGrid(cylinder, 1);
EXPECT_TRUE(testingVF::stdoutContainsWarning());
}
TEST_F(MultipleGridBuilderTestFixture, coarseGridExist_addGrid_doesNotWarn)
{
testingVF::captureStdOut();
- gridBuilder.addGrid(gridShape, 1);
+ gridBuilder.addGrid(cylinder, 1);
EXPECT_FALSE(testingVF::stdoutContainsWarning());
}
TEST(MultipleGridBuilderTest, noCoarseGrid_addGridWithoutLevel_warns)
{
MultipleGridBuilder gridBuilder;
- SPtr<Object> gridShape;
+ SPtr<Object> cylinder;
testingVF::captureStdOut();
- gridBuilder.addGrid(gridShape);
+ gridBuilder.addGrid(cylinder);
EXPECT_TRUE(testingVF::stdoutContainsWarning());
}
TEST_F(MultipleGridBuilderTestFixture, coarseGridExist_addGridWitoutLevel_doesNotWarn)
{
testingVF::captureStdOut();
- gridBuilder.addGrid(gridShape);
+ gridBuilder.addGrid(cylinder);
EXPECT_FALSE(testingVF::stdoutContainsWarning());
}
@@ -60,7 +67,7 @@ TEST_F(MultipleGridBuilderTestFixture, coarseGridExist_addGrid_addsGridToList)
{
uint levelFine = 1;
- gridBuilder.addGrid(gridShape, levelFine);
+ gridBuilder.addGrid(cylinder, levelFine);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2)) << "coarse level + 1 new level = 2 levels";
}
@@ -68,7 +75,7 @@ TEST_F(MultipleGridBuilderTestFixture, coarseGridExist_addGridAtLevelTwo_addsTwo
{
uint levelFine = 2;
- gridBuilder.addGrid(gridShape, levelFine);
+ gridBuilder.addGrid(cylinder, levelFine);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(3)) << "coarse level + 2 new levels = 3 levels";
}
@@ -76,10 +83,10 @@ TEST_F(MultipleGridBuilderTestFixture, fineGridExist_addGridAtLevelTwo_addsOneGr
{
uint levelFine = 2;
- gridBuilder.addGrid(gridShape, 1);
+ gridBuilder.addGrid(cylinder, 1);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2)) << "coarse level + fineLevel = 2 levels";
- gridBuilder.addGrid(gridShape, levelFine);
+ gridBuilder.addGrid(cylinder, levelFine);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(3)) << "coarse level + fineLevel + 1 new levels = 3 levels";
}
@@ -87,10 +94,10 @@ TEST_F(MultipleGridBuilderTestFixture, fineGridExist_addGridAtLevelThree_addsTwo
{
uint levelFine = 3;
- gridBuilder.addGrid(gridShape, 1);
+ gridBuilder.addGrid(cylinder, 1);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2)) << "coarse level + fineLevel = 2 levels";
- gridBuilder.addGrid(gridShape, levelFine);
+ gridBuilder.addGrid(cylinder, levelFine);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(4)) << "coarse level + fineLevel + 2 new levels = 4 levels";
}
@@ -98,10 +105,10 @@ TEST_F(MultipleGridBuilderTestFixture, fineGridExist_addGridAtSameLevel_noGridAd
{
uint levelFine = 1;
- gridBuilder.addGrid(gridShape, 1);
+ gridBuilder.addGrid(cylinder, 1);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2)) << "coarse level + fineLevel = 2 levels";
- gridBuilder.addGrid(gridShape, levelFine);
+ gridBuilder.addGrid(cylinder, levelFine);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2))
<< "Can't add grid on same level twice --> no new grid should be added";
}
@@ -110,7 +117,7 @@ TEST_F(MultipleGridBuilderTestFixture, addGrid_hasHalfDeltaComparedToCoarseGrid)
{
uint levelFine = 1;
- gridBuilder.addGrid(gridShape, levelFine);
+ gridBuilder.addGrid(cylinder, levelFine);
EXPECT_THAT(gridBuilder.getGrid(levelFine)->getDelta(), testing::Eq(0.5 * delta));
}
@@ -118,44 +125,73 @@ TEST_F(MultipleGridBuilderTestFixture, addGridAtLevelTwo_hasHalfOfHalfDeltaCompa
{
uint levelFine = 2;
- gridBuilder.addGrid(gridShape, levelFine);
+ gridBuilder.addGrid(cylinder, levelFine);
EXPECT_THAT(gridBuilder.getGrid(levelFine)->getDelta(), testing::Eq(0.5 * 0.5 * delta));
}
TEST_F(MultipleGridBuilderTestFixture, addGridWithoutLevel_addsGridAtLevelOne)
{
- gridBuilder.addGrid(gridShape);
+ gridBuilder.addGrid(cylinder);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2));
EXPECT_THAT(gridBuilder.getGrid(1)->getDelta(), testing::Eq(0.5 * delta));
}
TEST_F(MultipleGridBuilderTestFixture, fineGridExists_addGridWithoutLevel_addsGridAtLevelTwo)
{
- gridBuilder.addGrid(gridShape);
+ gridBuilder.addGrid(cylinder);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2));
EXPECT_THAT(gridBuilder.getGrid(1)->getDelta(), testing::Eq(0.5 * delta));
- gridBuilder.addGrid(gridShape);
+ gridBuilder.addGrid(cylinder);
EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(3));
EXPECT_THAT(gridBuilder.getGrid(2)->getDelta(), testing::Eq(0.5 * 0.5 * delta));
}
-TEST_F(MultipleGridBuilderTestFixture, addGridWithPredefinedDelta_hasCorrectDelta)
+TEST_F(MultipleGridBuilderTestFixture, addRotatingGrid_hasCorrectDelta)
{
- gridBuilder.addGridWithSameDeltaAsPreviousGrid(gridShape);
- EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(2));
- EXPECT_THAT(gridBuilder.getGrid(1)->getDelta(), RealEq(gridBuilder.getGrid(0)->getDelta()));
+ EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(1));
+ gridBuilder.addGridRotatingGrid(cylinder);
+ EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(1)) << "Rotating grid is not added to list of grids.";
+ EXPECT_THAT(gridBuilder.getGrid(0)->getDelta(), RealEq(gridBuilder.getRotatingGrid()->getDelta()));
- gridBuilder.addGridWithSameDeltaAsPreviousGrid(gridShape);
- EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(3));
- EXPECT_THAT(gridBuilder.getGrid(2)->getDelta(), RealEq(gridBuilder.getGrid(1)->getDelta()));
+ gridBuilder.addGridRotatingGrid(cylinder);
+ EXPECT_THAT(gridBuilder.getGrids().size(), testing::Eq(1)) << "Rotating grid is not added to list of grids.";
+ EXPECT_THAT(gridBuilder.getGrid(0)->getDelta(), RealEq(gridBuilder.getRotatingGrid()->getDelta()));
}
TEST(MultipleGridBuilderTest, noCoarseGrid_addGridWithPredefinedDelta_warns)
{
MultipleGridBuilder gridBuilder;
- SPtr<Object> gridShape;
-
+ SPtr<VerticalCylinder> cylinder;
+
testingVF::captureStdOut();
- gridBuilder.addGridWithSameDeltaAsPreviousGrid(gridShape);
+ gridBuilder.addGridRotatingGrid(cylinder);
EXPECT_TRUE(testingVF::stdoutContainsWarning());
}
+
+TEST_F(MultipleGridBuilderTestFixture, makeGrid_innerGridHasCorrectDimensions)
+{
+ const auto numberOfLevels = 1;
+ const auto grid = gridBuilder.makeGrid(cylinder, numberOfLevels, 0);
+
+ EXPECT_THAT(grid->getStartX(), RealNear(cylinder->getX1Minimum() - 0.25 * delta, 0.00005));
+ EXPECT_THAT(grid->getStartY(), RealNear(cylinder->getX2Minimum() - 0.25 * delta, 0.00005));
+ EXPECT_THAT(grid->getStartZ(), RealNear(cylinder->getX3Minimum() - 0.25 * delta, 0.00005));
+
+ EXPECT_THAT(grid->getEndX(), RealNear(cylinder->getX1Maximum() + 0.25 * delta, 0.00005));
+ EXPECT_THAT(grid->getEndY(), RealNear(cylinder->getX2Maximum() + 0.25 * delta, 0.00005));
+ EXPECT_THAT(grid->getEndZ(), RealNear(cylinder->getX3Maximum() + 0.25 * delta, 0.00005));
+}
+
+TEST_F(MultipleGridBuilderTestFixture, makeRotatingGrid_innerGridHasCorrectDimensions)
+{
+ const auto numberOfLevels = 1;
+ const auto grid = gridBuilder.makeRotatingGrid(cylinder, numberOfLevels, 0);
+
+ EXPECT_THAT(grid->getStartX(), RealNear(cylinder->getX1Minimum() - 0.5 * delta, 0.00005));
+ EXPECT_THAT(grid->getStartY(), RealNear(cylinder->getX2Minimum() - 0.5 * delta, 0.00005));
+ EXPECT_THAT(grid->getStartZ(), RealNear(cylinder->getX3Minimum() - 0.5 * delta, 0.00005));
+
+ EXPECT_THAT(grid->getEndX(), RealNear(cylinder->getX1Maximum() + 0.5 * delta, 0.00005));
+ EXPECT_THAT(grid->getEndY(), RealNear(cylinder->getX2Maximum() + 0.5 * delta, 0.00005));
+ EXPECT_THAT(grid->getEndZ(), RealNear(cylinder->getX3Maximum() + 0.5 * delta, 0.00005));
+}