Use new cylinder for rotating grid

apps/gpu/RotatingGrid/RotatingGrid.cpp

@@ -49,7 +49,7 @@
 //////////////////////////////////////////////////////////////////////////
 
 #include "GridGenerator/geometries/Cuboid/Cuboid.h"
-#include "GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h"
+#include "GridGenerator/geometries/Cylinder/Cylinder.h"
 #include "GridGenerator/grid/BoundaryConditions/Side.h"
 #include "GridGenerator/grid/GridBuilder/LevelGridBuilder.h"
 #include "GridGenerator/grid/GridBuilder/MultipleGridBuilder.h"
@@ -77,7 +77,7 @@ int main()
         // Simulation parameters
         //////////////////////////////////////////////////////////////////////////
         enum RotationOrInterpolation {Rot, Int};
-        const RotationOrInterpolation rotOrInt = Int;
+        const RotationOrInterpolation rotOrInt = Rot;
 
         const std::string path("./output/RotatingGrid");
         const std::string simulationName = rotOrInt == Int ? "RotatingGridInterpolationTest" : "RotatingGrid";
@@ -105,10 +105,10 @@ int main()
         //////////////////////////////////////////////////////////////////////////
         auto gridBuilder = std::make_shared<MultipleGridBuilder>();
 
-        gridBuilder->addCoarseGrid(-0.5 * L, -0.5 * L, -1.5 * L, 0.5 * L, 0.5 * L, 1.5 * L, dx);
+        gridBuilder->addCoarseGrid(-1.5 * L, -0.5 * L, -0.5 * L, 1.5 * L, 0.5 * L, 0.5 * L, dx);
 
-        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);
+        if (rotOrInt == Rot) gridBuilder->addGridRotatingGrid(std::make_shared<Cylinder>(0.0, 0.0, 0.0, 0.3 * L, 1. * L, Cylinder::PrincipalAxis::x));
+        if (rotOrInt == Int) gridBuilder->addGrid(std::make_shared<Cylinder>(0.0, 0.0, 0.0, 0.3 * L, 1. * L, Cylinder::PrincipalAxis::x), 1);
 
         GridScalingFactory scalingFactory = GridScalingFactory();
         scalingFactory.setScalingFactory(GridScalingFactory::GridScaling::ScaleCompressible);
@@ -142,13 +142,13 @@ int main()
         // set boundary conditions
         //////////////////////////////////////////////////////////////////////////
 
-        gridBuilder->setSlipBoundaryCondition(SideType::MX, 0.0, 0.0, 0.0);
-        gridBuilder->setSlipBoundaryCondition(SideType::PX, 0.0, 0.0, 0.0);
-        gridBuilder->setSlipBoundaryCondition(SideType::PY, 0.0, 0.0, 0.0);
         gridBuilder->setSlipBoundaryCondition(SideType::MY, 0.0, 0.0, 0.0);
+        gridBuilder->setSlipBoundaryCondition(SideType::PY, 0.0, 0.0, 0.0);
+        gridBuilder->setSlipBoundaryCondition(SideType::MZ, 0.0, 0.0, 0.0);
+        gridBuilder->setSlipBoundaryCondition(SideType::PZ, 0.0, 0.0, 0.0);
 
-        gridBuilder->setVelocityBoundaryCondition(SideType::MZ, 0.0, 0.0, velocityLB);
-        gridBuilder->setPressureBoundaryCondition(SideType::PZ, 0.0);
+        gridBuilder->setVelocityBoundaryCondition(SideType::MX, velocityLB, 0.0, 0.0);
+        gridBuilder->setPressureBoundaryCondition(SideType::PX, 0.0);
 
         BoundaryConditionFactory bcFactory;
 

src/gpu/GridGenerator/geometries/Cylinder/Cylinder.cpp

@@ -90,6 +90,11 @@ double Cylinder::getHeight() const
     return height;
 }
 
+Cylinder::PrincipalAxis Cylinder::getPrincipalAxis() const
+{
+    return principalAxis;
+}
+
 bool Cylinder::isInCircle(double delta1, double delta2, double offset) const
 {
     return (delta1 * delta1 + delta2 * delta2) < ((this->radius - offset) * (this->radius - offset));

src/gpu/GridGenerator/geometries/Cylinder/Cylinder.h

@@ -65,6 +65,7 @@ public:
 
     double getRadius() const;
     double getHeight() const;
+    PrincipalAxis getPrincipalAxis() const;
 
     bool isPointInObject(const double &x1, const double &x2, const double &x3, const double &minOffset,
                          const double &maxOffset) override;

src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp

@@ -45,7 +45,7 @@
 #include "grid/BoundaryConditions/Side.h"
 #include "grid/Grid.h"
 #include "grid/GridFactory.h"
-#include "geometries/VerticalCylinder/VerticalCylinder.h"
+#include "geometries/Cylinder/Cylinder.h"
 
 #include "io/GridVTKWriter/GridVTKWriter.h"
 #include "io/STLReaderWriter/STLWriter.h"
@@ -101,7 +101,7 @@ void MultipleGridBuilder::addGrid(SPtr<Object> gridShape)
     addGridToListIfValid(grid);
 }
 
-void MultipleGridBuilder::addGridRotatingGrid(SPtr<VerticalCylinder> cylinder)
+void MultipleGridBuilder::addGridRotatingGrid(SPtr<Cylinder> cylinder)
 {
     if (!coarseGridExists()) return emitNoCoarseGridExistsWarning();
 
@@ -246,7 +246,7 @@ SPtr<Grid> MultipleGridBuilder::makeGrid(SPtr<Object> gridShape, uint level, uin
     return newGrid;
 }
 
-SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<VerticalCylinder> cylinder, uint level, uint levelFine)
+SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<Cylinder> cylinder, uint level, uint levelFine)
 {
     boundaryConditions.push_back(std::make_shared<BoundaryConditions>());
 
@@ -259,20 +259,9 @@ SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<VerticalCylinder> cylinder
     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);
-
     // #TODO: change next line to use staggering
-    cylinder = std::make_shared<VerticalCylinder>(cylinder->getX1Centroid(), cylinder->getX2Centroid(),
-                                                  cylinder->getX3Centroid(), cylinder->getRadius() + 6.0 * delta,
-                                                  cylinder->getHeight() + 6.0 * delta);
-    VF_LOG_WARNING("RotGr: LargerCylinder Size x : {}, {} \n z: {}, {}", cylinder->getX1Minimum(), cylinder->getX1Maximum(),
-                   cylinder->getX3Minimum(), cylinder->getX3Maximum());
+    cylinder = std::make_shared<Cylinder>(cylinder->getX1Centroid(), cylinder->getX2Centroid(), cylinder->getX3Centroid(),
+                                          cylinder->getRadius() + 6.0 * delta, cylinder->getHeight() + 6.0 * delta, cylinder->getPrincipalAxis());
 
     SPtr<Grid> newGrid = this->makeGrid(cylinder, staggeredCoordinates[0],
                                                   staggeredCoordinates[1],

src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.h

@@ -45,7 +45,7 @@
 
 class Object;
 class BoundingBox;
-class VerticalCylinder;
+class Cylinder;
 
 class MultipleGridBuilder : public LevelGridBuilder
 {
@@ -54,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 addGridRotatingGrid(SPtr<VerticalCylinder> cylinder);
+    GRIDGENERATOR_EXPORT void addGridRotatingGrid(SPtr<Cylinder> cylinder);
     GRIDGENERATOR_EXPORT void addGrid(SPtr<Object> gridShape, uint levelFine);
 
     GRIDGENERATOR_EXPORT void addGeometry(SPtr<Object> gridShape);
@@ -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<VerticalCylinder> cylinder, uint level, uint levelFine);
+    virtual SPtr<Grid> makeRotatingGrid(SPtr<Cylinder> cylinder, uint level, uint levelFine);
 
 private:
     void addGridToList(SPtr<Grid> grid);

src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilderTest.cpp

 #include "basics/tests/testUtilities.h"
-#include "geometries/VerticalCylinder/VerticalCylinder.h"
+#include "geometries/Cylinder/Cylinder.h"
 #include "grid/GridBuilder/MultipleGridBuilder.h"
 
 class MultipleGridBuilderForTest: public MultipleGridBuilder{
@@ -12,13 +12,13 @@ class MultipleGridBuilderTestFixture : public testing::Test
 {
 protected:
     MultipleGridBuilderForTest gridBuilder;
-    SPtr<VerticalCylinder> cylinder;
+    SPtr<Cylinder> cylinder;
     real delta = 0.1;
 
 public:
     void SetUp() override
     {
-        cylinder = std::make_shared<VerticalCylinder>(0.0, 0.0, 0.0, 2.0, 8.0);
+        cylinder = std::make_shared<Cylinder>(0.0, 0.0, 0.0, 2.0, 8.0, Cylinder::PrincipalAxis::x);
         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);
     }
@@ -161,7 +161,7 @@ TEST_F(MultipleGridBuilderTestFixture, addRotatingGrid_hasCorrectDelta)
 TEST(MultipleGridBuilderTest, noCoarseGrid_addGridWithPredefinedDelta_warns)
 {
     MultipleGridBuilder gridBuilder;
-    SPtr<VerticalCylinder> cylinder;
+    SPtr<Cylinder> cylinder;
 
     testingVF::captureStdOut();
     gridBuilder.addGridRotatingGrid(cylinder);