- add test for staggered grid

src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp

@@ -76,12 +76,46 @@ uint MultipleGridBuilder<Grid>::getNumberOfLevels() const
 template <typename Grid>
 real MultipleGridBuilder<Grid>::getDelta(int level) const
 {
+    if (grids.empty())
+        throw InvalidLevelException();
     return grids[level]->getDelta();
 }
 
+template <typename Grid>
+real MultipleGridBuilder<Grid>::getStartX(uint level) const
+{
+    return 0.0;
+}
 
+template <typename Grid>
+real MultipleGridBuilder<Grid>::getStartY(uint level) const
+{
+    return 0.0;
+}
 
+template <typename Grid>
+real MultipleGridBuilder<Grid>::getStartZ(uint level) const
+{
+    return 0.0;
+}
 
+template <typename Grid>
+real MultipleGridBuilder<Grid>::getEndX(uint level) const
+{
+    return 0.0;
+}
+
+template <typename Grid>
+real MultipleGridBuilder<Grid>::getEndY(uint level) const
+{
+    return 0.0;
+}
+
+template <typename Grid>
+real MultipleGridBuilder<Grid>::getEndZ(uint level) const
+{
+    return 0.0;
+}
 
 
 template class MultipleGridBuilder<GridDummy>;

src/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h

@@ -37,6 +37,17 @@ public:
     }
 };
 
+class InvalidLevelException : public MultipleGridBuilderException
+{
+public:
+    const char* what() const noexcept override
+    {
+        std::ostringstream getNr;
+        getNr << "level is invalid.";
+        return getNr.str().c_str();
+    }
+};
+
 template<typename Grid>
 class MultipleGridBuilder
 {
@@ -51,6 +62,14 @@ public:
     VF_PUBLIC uint getNumberOfLevels() const;
     VF_PUBLIC real getDelta(int level) const;
 
+    VF_PUBLIC real getStartX(uint level) const;
+    VF_PUBLIC real getStartY(uint level) const;
+    VF_PUBLIC real getStartZ(uint level) const;
+
+    VF_PUBLIC real getEndX(uint level) const;
+    VF_PUBLIC real getEndY(uint level) const;
+    VF_PUBLIC real getEndZ(uint level) const;
+
 private:
     bool isInsideOfGrids(SPtr<Grid> grid) const;
     real calculateDelta();

src/GridGenerator/grid/GridBuilder/MultipleGridBuilderTest.cpp

@@ -39,17 +39,84 @@ TEST(MultipleGridBuilderTest, firstGridMustBeCoarse)
     ASSERT_THROW(gridBuilder->addGrid(0.0, 0.0, 0.0, 20.0, 20.0, 20.0), FirstGridMustBeCoarseException);
 }
 
+TEST(MultipleGridBuilderTest, addMultipleGrids_deltaShouldBeTheHalfOfTheLastAdded)
+{
+    auto gridBuilder = MultipleGridBuilder<GridDummy>::makeShared();
+    const real delta = 2.0;
+    gridBuilder->addCoarseGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, delta);
+
+    gridBuilder->addGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
+    gridBuilder->addGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
+    gridBuilder->addGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
+    gridBuilder->addGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
+
+    EXPECT_THAT(gridBuilder->getDelta(1), RealEq(delta / 2.0));
+    EXPECT_THAT(gridBuilder->getDelta(2), RealEq(delta / 4.0));
+    EXPECT_THAT(gridBuilder->getDelta(3), RealEq(delta / 8.0));
+    EXPECT_THAT(gridBuilder->getDelta(4), RealEq(delta / 16.0));
+}
+
+TEST(MultipleGridBuilderTest, getInvalidLevel_shouldThrowException)
+{
+    auto gridBuilder = MultipleGridBuilder<GridDummy>::makeShared();
+
+    ASSERT_THROW(gridBuilder->getDelta(0), InvalidLevelException);
+}
+
+TEST(MultipleGridBuilderTest, addedsecondGrid_shouldBeStaggered)
+{
+    auto gridBuilder = MultipleGridBuilder<GridDummy>::makeShared();
+    gridBuilder->addCoarseGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, 1.0);
+
+    const real givenStartX = 0.0;
+    const real givenStartY = 0.0;
+    const real givenStartZ = 0.0;
+
+    const real givenEndX = 10.0;
+    const real givenEndY = 10.0;
+    const real givenEndZ = 10.0;
+    gridBuilder->addGrid(givenStartX, givenStartY, givenStartZ, givenEndX, givenEndY, givenEndZ);
+
+    const uint level = 1;
+    const real staggeredOffset = 0.5 * gridBuilder->getDelta(level);
+
+    const real expectedStartX = givenStartX + staggeredOffset;
+    const real expectedStartY = givenStartY + staggeredOffset;
+    const real expectedStartZ = givenStartZ + staggeredOffset;
+
+    const real actualStartX = gridBuilder->getStartX(level);
+    const real actualStartY = gridBuilder->getStartY(level);
+    const real actualStartZ = gridBuilder->getStartZ(level);
+
+    EXPECT_THAT(actualStartX, RealEq(expectedStartX));
+    EXPECT_THAT(actualStartY, RealEq(expectedStartY));
+    EXPECT_THAT(actualStartZ, RealEq(expectedStartZ));
+
+
+    const real expectedEndX = givenEndX - staggeredOffset;
+    const real expectedEndY = givenEndY - staggeredOffset;
+    const real expectedEndZ = givenEndZ - staggeredOffset;
+
+
+    const real actualEndX = gridBuilder->getEndX(level);
+    const real actualEndY = gridBuilder->getEndY(level);
+    const real actualEndZ = gridBuilder->getEndZ(level);
+
+    EXPECT_THAT(actualEndX, RealEq(expectedEndX));
+    EXPECT_THAT(actualEndY, RealEq(expectedEndY));
+    EXPECT_THAT(actualEndZ, RealEq(expectedEndZ));
+}
 
-//TEST(MultipleGridBuilderTest, fall2)
+//TEST(MultipleGridBuilderTest, addsFineGridWithLevel_shouldCreateGridsBetween)
 //{
 //    auto gridBuilder = MultipleGridBuilder<GridDummy>::makeShared();
 //
 //    real delta = 2.0;
-//    gridBuilder->addCoarseGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, delta, true, true, true);
-//    gridBuilder->addGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, true, true, true);
+//    gridBuilder->addCoarseGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, delta);
+//    gridBuilder->addGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0);
 //
 //    uint level = 5;
-//    gridBuilder->addFineGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, level, true, true, true);
+//    gridBuilder->addFineGrid(0.0, 0.0, 0.0, 10.0, 10.0, 10.0, level);
 //
-//    ASSERT_THROW(gridBuilder->addGrid(0.0, 0.0, 0.0, 20.0, 20.0, 20.0, true, true, true), FinerGridBiggerThanCoarsestGridException);
+//    ASSERT_THROW(gridBuilder->addGrid(0.0, 0.0, 0.0, 20.0, 20.0, 20.0), FinerGridBiggerThanCoarsestGridException);
 //}