diff --git a/apps/gpu/RotatingGrid/RotatingGrid.cpp b/apps/gpu/RotatingGrid/RotatingGrid.cpp
index 7279caf1a18a2770a1fb930a89e5b306bced34f3..bc13d54b46fdd4421eb69c9305ad3daaab792078 100644
--- a/apps/gpu/RotatingGrid/RotatingGrid.cpp
+++ b/apps/gpu/RotatingGrid/RotatingGrid.cpp
@@ -77,7 +77,7 @@ int main()
// Simulation parameters
//////////////////////////////////////////////////////////////////////////
enum RotationOrInterpolation {Rot, Int};
- const RotationOrInterpolation rotOrInt = Rot;
+ const RotationOrInterpolation rotOrInt = Int;
const std::string path("./output/RotatingGrid");
const std::string simulationName = rotOrInt == Int ? "RotatingGridInterpolationTest" : "RotatingGrid";
@@ -197,7 +197,7 @@ int main()
Simulation sim(para, cudaMemoryManager, communicator, *gridGenerator, &bcFactory, &scalingFactory);
- const std::string gridName = rotOrInt == Rot ? "rot_grid" : "rot";
+ const std::string gridName = rotOrInt == Rot ? "rot_grid" : "grid";
gridBuilder->writeGridsToVtk(para->getOutputPath() + gridName);
// NeighborDebugWriter::writeNeighborLinkLinesDebug(para.get());
diff --git a/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.cpp b/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.cpp
index b41813e12da1727ba03b7f179c93b4c6b042b76f..fbbf7460e9ec17946171f0f228ead6718ba13543 100644
--- a/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.cpp
+++ b/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.cpp
@@ -162,13 +162,13 @@ bool Conglomerate::isPointInObject(const double& x1, const double& x2, const dou
return false;
}
-void Conglomerate::scale(double delta)
+void Conglomerate::changeSizeByDelta(double delta)
{
for (uint i = 0; i < numberOfAddObjects; i++)
- addObjects[i]->scale(delta);
+ addObjects[i]->changeSizeByDelta(delta);
for (uint i = 0; i < numberOfSubtractObjects; i++)
- subtractObjects[i]->scale(delta);
+ subtractObjects[i]->changeSizeByDelta(delta);
}
void Conglomerate::findInnerNodes(SPtr<GridImp> grid)
diff --git a/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h b/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h
index 0b3f7ad7b67554b72ad78188d68d9570bf21e090..ed6caace2bd3d99bd119c0771f1f5312a815dc40 100644
--- a/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h
+++ b/src/gpu/GridGenerator/geometries/Conglomerate/Conglomerate.h
@@ -63,7 +63,7 @@ public:
double getX3Minimum() override;
double getX3Maximum() override;
- void scale(double delta) override;
+ void changeSizeByDelta(double delta) override;
bool isPointInObject(const double& x1, const double& x2, const double& x3, const double& minOffset, const double& maxOffset) override;
diff --git a/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.cpp b/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.cpp
index 2cf56a867954abecf14f7dc2a74f735ebb0660a7..e6c05313b24a656ed9171f7385d0c68a3fd7f9f6 100644
--- a/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.cpp
+++ b/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.cpp
@@ -131,7 +131,7 @@ bool Cuboid::isBetween(const real& coord, const real& start, const real& end)
}
-void Cuboid::scale(double delta)
+void Cuboid::changeSizeByDelta(double delta)
{
this->minX1 -= delta;
this->minX2 -= delta;
diff --git a/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h b/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h
index 7ff5c14c2f17b4ed80f4f1e0c03d26ea1a2eb196..152a8dc6b6dd89c565ec55e49c943a5d18dab782 100644
--- a/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h
+++ b/src/gpu/GridGenerator/geometries/Cuboid/Cuboid.h
@@ -54,7 +54,7 @@ public:
double getX3Minimum() override;
double getX3Maximum() override;
- void scale(double delta) override;
+ void changeSizeByDelta(double delta) override;
bool isPointInObject(const double& x1, const double& x2, const double& x3, const double& minOffset, const double& maxOffset) override;
diff --git a/src/gpu/GridGenerator/geometries/Cylinder/Cylinder.cpp b/src/gpu/GridGenerator/geometries/Cylinder/Cylinder.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a102e01cd211f3a46d24f92e5541613a2b939d9e
--- /dev/null
+++ b/src/gpu/GridGenerator/geometries/Cylinder/Cylinder.cpp
@@ -0,0 +1,128 @@
+#include "Cylinder.h"
+#include <numeric>
+
+Cylinder::Cylinder(double centerX, double centerY, double centerZ, double radius, double height, PrincipalAxis axis)
+ : center({ centerX, centerY, centerZ }), radius(radius), height(height), principalAxis(axis)
+{
+}
+
+Cylinder::Cylinder(std::array<double, 3> center, double radius, double height, PrincipalAxis axis)
+ : center(center), radius(radius), height(height), principalAxis(axis)
+{
+}
+
+SPtr<Object> Cylinder::clone() const
+{
+ return std::make_shared<Cylinder>(center, radius, height, principalAxis);
+}
+
+double Cylinder::getCentroidCoordinate(PrincipalAxis coordinateDirection) const
+{
+ return center.at(coordinateDirection);
+}
+
+double Cylinder::getMinimunCoordinate(PrincipalAxis coordinateDirection) const
+{
+ const auto unitVector = unitVectors.at(principalAxis);
+ return center.at(coordinateDirection) - 0.5 * height * unitVector.at(coordinateDirection) +
+ radius * (unitVector.at(coordinateDirection) - 1);
+}
+
+double Cylinder::getMaximumCoordinate(PrincipalAxis coordinateDirection) const
+{
+ const auto unitVector = unitVectors.at(principalAxis);
+ return center.at(coordinateDirection) + 0.5 * height * unitVector.at(coordinateDirection) -
+ radius * (unitVector.at(coordinateDirection) - 1);
+}
+
+double Cylinder::getX1Centroid()
+{
+ return getCentroidCoordinate(x);
+}
+
+double Cylinder::getX1Minimum()
+{
+ return getMinimunCoordinate(x);
+}
+
+double Cylinder::getX1Maximum()
+{
+ return getMaximumCoordinate(x);
+}
+
+double Cylinder::getX2Centroid()
+{
+ return getCentroidCoordinate(y);
+}
+
+double Cylinder::getX2Minimum()
+{
+ return getMinimunCoordinate(y);
+}
+
+double Cylinder::getX2Maximum()
+{
+ return getMaximumCoordinate(y);
+}
+
+double Cylinder::getX3Centroid()
+{
+ return getCentroidCoordinate(z);
+}
+
+double Cylinder::getX3Minimum()
+{
+ return getMinimunCoordinate(z);
+}
+
+double Cylinder::getX3Maximum()
+{
+ return getMaximumCoordinate(z);
+}
+
+double Cylinder::getRadius() const
+{
+ return radius;
+}
+
+double Cylinder::getHeight() const
+{
+ return height;
+}
+
+bool Cylinder::isInCircle(double delta1, double delta2, double offset) const
+{
+ return (delta1 * delta1 + delta2 * delta2) < ((this->radius - offset) * (this->radius - offset));
+}
+
+bool Cylinder::isPointInObject(const double &x1, const double &x2, const double &x3, const double &minOffset,
+ const double &maxOffset)
+{
+ double offset = maxOffset;
+ if (x1 < center.at(x) || x2 < center.at(y) || x3 < center.at(z)) offset = minOffset;
+
+ const double deltaX1 = x1 - center.at(x);
+ const double deltaX2 = x2 - center.at(y);
+ const double deltaX3 = x3 - center.at(z);
+
+ switch (principalAxis) {
+ case x:
+ if (deltaX1 > 0.5 * height || deltaX1 < -0.5 * height) return false;
+ return isInCircle(deltaX2, deltaX3, offset);
+ case y:
+ if (deltaX2 > 0.5 * height || deltaX2 < -0.5 * height) return false;
+ return isInCircle(deltaX1, deltaX3, offset);
+ case z:
+ if (deltaX3 > 0.5 * height || deltaX3 < -0.5 * height) return false;
+ return isInCircle(deltaX1, deltaX2, offset);
+ }
+
+ VF_LOG_CRITICAL("Unknown principal axis in Cylinder.");
+ return false;
+}
+
+void Cylinder::changeSizeByDelta(double delta)
+{
+ this->radius += delta;
+ this->height += 2 * delta;
+}
\ No newline at end of file
diff --git a/src/gpu/GridGenerator/geometries/Cylinder/Cylinder.h b/src/gpu/GridGenerator/geometries/Cylinder/Cylinder.h
new file mode 100644
index 0000000000000000000000000000000000000000..5af1f3b15f205f5a44196a984ebd551c047e51fd
--- /dev/null
+++ b/src/gpu/GridGenerator/geometries/Cylinder/Cylinder.h
@@ -0,0 +1,91 @@
+//=======================================================================================
+// ____ ____ __ ______ __________ __ __ __ __
+// \ \ | | | | | _ \ |___ ___| | | | | / \ | |
+// \ \ | | | | | |_) | | | | | | | / \ | |
+// \ \ | | | | | _ / | | | | | | / /\ \ | |
+// \ \ | | | | | | \ \ | | | \__/ | / ____ \ | |____
+// \ \ | | |__| |__| \__\ |__| \________/ /__/ \__\ |_______|
+// \ \ | | ________________________________________________________________
+// \ \ | | | ______________________________________________________________|
+// \ \| | | | __ __ __ __ ______ _______
+// \ | | |_____ | | | | | | | | | _ \ / _____)
+// \ | | _____| | | | | | | | | | | \ \ \_______
+// \ | | | | |_____ | \_/ | | | | |_/ / _____ |
+// \ _____| |__| |________| \_______/ |__| |______/ (_______/
+//
+// This file is part of VirtualFluids. VirtualFluids is free software: you can
+// redistribute it and/or modify it under the terms of the GNU General Public
+// License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// VirtualFluids is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+// for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with VirtualFluids (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>.
+//
+//! \file Cylinder.h
+//! \ingroup geometries
+//! \author Anna Wellmann
+//=======================================================================================
+
+
+#ifndef CYLINDER_H
+#define CYLINDER_H
+
+#include "geometries/Object.h"
+#include <basics/geometry3d/GbCylinder3D.h>
+#include <map>
+
+class GRIDGENERATOR_EXPORT Cylinder : public Object
+{
+public:
+ enum PrincipalAxis {
+ x = 0,
+ y = 1,
+ z = 2,
+ };
+
+ Cylinder(double centerX, double centerY, double centerZ, double radius, double height, PrincipalAxis axis);
+ Cylinder(std::array<double, 3> center, double radius, double height, PrincipalAxis axis);
+
+ SPtr<Object> clone() const override;
+
+ double getX1Centroid() override;
+ double getX1Minimum() override;
+ double getX1Maximum() override;
+ double getX2Centroid() override;
+ double getX2Minimum() override;
+ double getX2Maximum() override;
+ double getX3Centroid() override;
+ 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;
+ void changeSizeByDelta(double delta) override;
+
+private:
+ double getCentroidCoordinate(PrincipalAxis coordinateDirection) const;
+ double getMinimunCoordinate(PrincipalAxis coordinateDirection) const;
+ double getMaximumCoordinate(PrincipalAxis coordinateDirection) const;
+
+ bool isInCircle(double delta1, double delta2, double offset) const;
+
+ const std::map<PrincipalAxis, std::array<double, 3>> unitVectors{ { x, { 1, 0, 0 } },
+ { y, { 0, 1, 0 } },
+ { z, { 0, 0, 1 } } };
+
+ PrincipalAxis principalAxis;
+ const std::array<double, 3> center;
+
+ double radius;
+ double height;
+};
+
+#endif
\ No newline at end of file
diff --git a/src/gpu/GridGenerator/geometries/Cylinder/CylinderTest.cpp b/src/gpu/GridGenerator/geometries/Cylinder/CylinderTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c0582f488783adc5fb5678d9b482ba151cbd9a2
--- /dev/null
+++ b/src/gpu/GridGenerator/geometries/Cylinder/CylinderTest.cpp
@@ -0,0 +1,212 @@
+#include <gmock/gmock.h>
+
+#include "Cylinder.h"
+
+
+void testChangeSizeByDelta(Cylinder &cylinder)
+{
+ const double delta = 0.2;
+ const double tolerance = 0.0000000001;
+ const double oldRadius = cylinder.getRadius();
+ const double oldHeight = cylinder.getHeight();
+ const double oldMinimumX1 = cylinder.getX1Minimum();
+ const double oldMinimumX2 = cylinder.getX2Minimum();
+ const double oldMinimumX3 = cylinder.getX3Minimum();
+ const double oldMaximumX1 = cylinder.getX1Maximum();
+ const double oldMaximumX2 = cylinder.getX2Maximum();
+ const double oldMaximumX3 = cylinder.getX3Maximum();
+
+ cylinder.changeSizeByDelta(delta);
+
+ EXPECT_THAT(cylinder.getRadius(), testing::Eq(oldRadius + delta));
+ EXPECT_THAT(cylinder.getHeight(), testing::Eq(oldHeight + 2 * delta));
+ EXPECT_THAT(cylinder.getX1Minimum(), testing::DoubleNear(oldMinimumX1 - delta, tolerance));
+ EXPECT_THAT(cylinder.getX2Minimum(), testing::DoubleNear(oldMinimumX2 - delta, tolerance));
+ EXPECT_THAT(cylinder.getX3Minimum(), testing::DoubleNear(oldMinimumX3 - delta, tolerance));
+ EXPECT_THAT(cylinder.getX1Maximum(), testing::DoubleNear(oldMaximumX1 + delta, tolerance));
+ EXPECT_THAT(cylinder.getX2Maximum(), testing::DoubleNear(oldMaximumX2 + delta, tolerance));
+ EXPECT_THAT(cylinder.getX3Maximum(), testing::DoubleNear(oldMaximumX3 + delta, tolerance));
+}
+
+// CylinderTestAxisNormalToX ////////////////////////////////////////////////
+
+class CylinderTestAxisNormalToX : public testing::Test
+{
+public:
+ std::array<double, 3> center = { 0.1, 0.2, 0.3 };
+ double radius = 2.0;
+ double height = 8.0;
+ Cylinder cylinder = Cylinder(center[0], center[1], center[2], radius, height, Cylinder::PrincipalAxis::x);
+};
+
+TEST_F(CylinderTestAxisNormalToX, getCentroid)
+{
+ EXPECT_THAT(cylinder.getX1Centroid(), testing::Eq(center[0]));
+ EXPECT_THAT(cylinder.getX2Centroid(), testing::Eq(center[1]));
+ EXPECT_THAT(cylinder.getX3Centroid(), testing::Eq(center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToX, getMinimum)
+{
+ EXPECT_THAT(cylinder.getX1Minimum(), testing::Eq(-0.5 * height + center[0]));
+ EXPECT_THAT(cylinder.getX2Minimum(), testing::Eq(-radius + center[1]));
+ EXPECT_THAT(cylinder.getX3Minimum(), testing::Eq(-radius + center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToX, getMaximum)
+{
+ EXPECT_THAT(cylinder.getX1Maximum(), testing::Eq(0.5 * height + center[0]));
+ EXPECT_THAT(cylinder.getX2Maximum(), testing::Eq(radius + center[1]));
+ EXPECT_THAT(cylinder.getX3Maximum(), testing::Eq(radius + center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToX, isPointInObject)
+{
+ double epsilon = 0.0001;
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2], 0.0, 0.0));
+
+ // x
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] - 0.5 * height + epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] - 0.5 * height - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] + 0.5 * height - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] + 0.5 * height + epsilon, center[1], center[2], 0.0, 0.0));
+
+ // y
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] - radius + epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] - radius - epsilon, center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] + radius - epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] + radius + epsilon, center[2], 0.0, 0.0));
+
+ // z
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] - radius + epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] - radius - epsilon, 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] + radius - epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] + radius + epsilon, 0.0, 0.0));
+}
+
+TEST_F(CylinderTestAxisNormalToX, changeSizeByDelta)
+{
+ testChangeSizeByDelta(cylinder);
+}
+
+// CylinderTestAxisNormalToY ////////////////////////////////////////////////
+
+class CylinderTestAxisNormalToY : public testing::Test
+{
+protected:
+ std::array<double, 3> center = { 0.1, 0.2, 0.3 };
+ double radius = 2.0;
+ double height = 8.0;
+ Cylinder cylinder = Cylinder({ center[0], center[1], center[2] }, radius, height, Cylinder::PrincipalAxis::y);
+};
+
+TEST_F(CylinderTestAxisNormalToY, getCentroid)
+{
+ EXPECT_THAT(cylinder.getX1Centroid(), testing::Eq(center[0]));
+ EXPECT_THAT(cylinder.getX2Centroid(), testing::Eq(center[1]));
+ EXPECT_THAT(cylinder.getX3Centroid(), testing::Eq(center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToY, getMinimum)
+{
+ EXPECT_THAT(cylinder.getX1Minimum(), testing::Eq(-radius + center[0]));
+ EXPECT_THAT(cylinder.getX2Minimum(), testing::Eq(-0.5 * height + center[1]));
+ EXPECT_THAT(cylinder.getX3Minimum(), testing::Eq(-radius + center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToY, getMaximum)
+{
+ EXPECT_THAT(cylinder.getX1Maximum(), testing::Eq(radius + center[0]));
+ EXPECT_THAT(cylinder.getX2Maximum(), testing::Eq(0.5 * height + center[1]));
+ EXPECT_THAT(cylinder.getX3Maximum(), testing::Eq(radius + center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToY, isPointInObject)
+{
+ double epsilon = 0.0001;
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2], 0.0, 0.0));
+
+ // x
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] - radius + epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] - radius - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] + radius - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] + radius + epsilon, center[1], center[2], 0.0, 0.0));
+
+ // y
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] - 0.5 * height + epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] - 0.5 * height - epsilon, center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] + 0.5 * height - epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] + 0.5 * height + epsilon, center[2], 0.0, 0.0));
+
+ // z
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] - radius + epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] - radius - epsilon, 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] + radius - epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] + radius + epsilon, 0.0, 0.0));
+}
+
+TEST_F(CylinderTestAxisNormalToY, changeSizeByDelta)
+{
+ testChangeSizeByDelta(cylinder);
+}
+
+// CylinderTestAxisNormalToZ ////////////////////////////////////////////////
+
+class CylinderTestAxisNormalToZ : public testing::Test
+{
+protected:
+ std::array<double, 3> center = { 0.1, 0.2, 0.3 };
+ double radius = 2.0;
+ double height = 8.0;
+ Cylinder cylinder = Cylinder({ center[0], center[1], center[2] }, radius, height, Cylinder::PrincipalAxis::z);
+};
+
+TEST_F(CylinderTestAxisNormalToZ, getCentroid)
+{
+ EXPECT_THAT(cylinder.getX1Centroid(), testing::Eq(center[0]));
+ EXPECT_THAT(cylinder.getX2Centroid(), testing::Eq(center[1]));
+ EXPECT_THAT(cylinder.getX3Centroid(), testing::Eq(center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToZ, getMinimum)
+{
+ EXPECT_THAT(cylinder.getX1Minimum(), testing::Eq(-radius + center[0]));
+ EXPECT_THAT(cylinder.getX2Minimum(), testing::Eq(-radius + center[1]));
+ EXPECT_THAT(cylinder.getX3Minimum(), testing::Eq(-0.5 * height + center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToZ, getMaximum)
+{
+ EXPECT_THAT(cylinder.getX1Maximum(), testing::Eq(radius + center[0]));
+ EXPECT_THAT(cylinder.getX2Maximum(), testing::Eq(radius + center[1]));
+ EXPECT_THAT(cylinder.getX3Maximum(), testing::Eq(0.5 * height + center[2]));
+}
+
+TEST_F(CylinderTestAxisNormalToZ, isPointInObject)
+{
+ double epsilon = 0.0001;
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2], 0.0, 0.0));
+
+ // x
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] - radius + epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] - radius - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] + radius - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] + radius + epsilon, center[1], center[2], 0.0, 0.0));
+
+ // y
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] - radius + epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] - radius - epsilon, center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] + radius - epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] + radius + epsilon, center[2], 0.0, 0.0));
+
+ // z
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] - 0.5 * height + epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] - 0.5 * height - epsilon, 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] + 0.5 * height - epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] + 0.5 * height + epsilon, 0.0, 0.0));
+}
+
+TEST_F(CylinderTestAxisNormalToZ, changeSizeByDelta)
+{
+ testChangeSizeByDelta(cylinder);
+}
diff --git a/src/gpu/GridGenerator/geometries/Object.h b/src/gpu/GridGenerator/geometries/Object.h
index 8bb0a35d5e38df1f7db390fdf5ee750295788395..4448a45aecd2c89188ff955c570cf7fd38c2ba3b 100644
--- a/src/gpu/GridGenerator/geometries/Object.h
+++ b/src/gpu/GridGenerator/geometries/Object.h
@@ -59,7 +59,7 @@ public:
virtual double getX3Maximum() = 0;
- virtual void scale(double delta) = 0;
+ virtual void changeSizeByDelta(double delta) = 0;
virtual bool isPointInObject(const double& x1, const double& x2, const double& x3, const double& minOffset, const double& maxOffset) = 0;
diff --git a/src/gpu/GridGenerator/geometries/Sphere/Sphere.cpp b/src/gpu/GridGenerator/geometries/Sphere/Sphere.cpp
index 4669bbcfb9848a910bc86f9331a394daf6c55dd5..212ecc90019d6ab87230b4faa717da2d754fc75c 100644
--- a/src/gpu/GridGenerator/geometries/Sphere/Sphere.cpp
+++ b/src/gpu/GridGenerator/geometries/Sphere/Sphere.cpp
@@ -115,7 +115,7 @@ bool Sphere::isPointInObject(const double& x1, const double& x2, const double& x
}
-void Sphere::scale(double delta)
+void Sphere::changeSizeByDelta(double delta)
{
this->radius += delta;
}
diff --git a/src/gpu/GridGenerator/geometries/Sphere/Sphere.h b/src/gpu/GridGenerator/geometries/Sphere/Sphere.h
index 9ac8821a9c95fce8de16c22688ef3c585197804a..99d055ec1ba04117d4fdd525520a277d8129e9f7 100644
--- a/src/gpu/GridGenerator/geometries/Sphere/Sphere.h
+++ b/src/gpu/GridGenerator/geometries/Sphere/Sphere.h
@@ -59,7 +59,7 @@ public:
bool isPointInObject(const double& x1, const double& x2, const double& x3, const double& minOffset, const double& maxOffset) override;
- void scale(double delta) override;
+ void changeSizeByDelta(double delta) override;
int getIntersection(const Vertex &P, const Vertex &direction, Vertex &pointOnObject, real &qVal) override;
diff --git a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cpp b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cpp
index 91bb8f030e76fa6e083e7765feb18c7ccc517ee1..e5ab3c83291b8f4fd27bb3eee5f26d3fcdb69278 100644
--- a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cpp
+++ b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.cpp
@@ -185,7 +185,7 @@ bool intersectPlane(const Vertex &normal, const Vertex &pointOnPlane, const Vert
return false;
}
-void TriangularMesh::scale(double offset)
+void TriangularMesh::changeSizeByDelta(double offset)
{
std::vector<Triangle> triangles = this->triangleVec;
diff --git a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
index 7c050dd70b3908f3e4b021872887c74833594a26..5083e2adf9a91fcf9f8cfdb6da83d38a9eb19a9d 100644
--- a/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
+++ b/src/gpu/GridGenerator/geometries/TriangularMesh/TriangularMesh.h
@@ -97,7 +97,7 @@ public:
double getX3Centroid() override { throw "Not implemented in TriangularMesh"; }
double getX3Minimum() override { return minmax.minZ; }
double getX3Maximum() override { return minmax.maxZ; }
- void scale(double delta) override;
+ void changeSizeByDelta(double delta) override;
bool isPointInObject(const double& x1, const double& x2, const double& x3, const double& minOffset,
const double& maxOffset) override {
return false;
diff --git a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp
index 102fb258bcc7c5d46e88b3a33c11488b728fc267..439585ff246f82a7e820f514ecd5ed609f441797 100644
--- a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp
+++ b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.cpp
@@ -111,10 +111,10 @@ bool VerticalCylinder::isPointInObject(const double& x1, const double& x2, const
}
-void VerticalCylinder::scale(double delta)
+void VerticalCylinder::changeSizeByDelta(double delta)
{
this->radius += delta;
- this->height += delta;
+ this->height += 2 * delta;
}
double VerticalCylinder::getRadius() const
diff --git a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
index 8e4fae42ba4b18be725f8b7abe06b0fbffc417f7..3ffcba063e78b45f7965f5e7fe3909c7437b27ab 100644
--- a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
+++ b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinder.h
@@ -40,6 +40,7 @@ class GRIDGENERATOR_EXPORT VerticalCylinder : public Object
{
public:
VerticalCylinder(const double& centerX, const double& centerY, const double& centerZ, const double& radius, const double& height);
+ // the axis is in the z-direction
static SPtr<VerticalCylinder> makeShared(double centerX, double centerY, double centerZ, double radius, double height);
@@ -61,8 +62,8 @@ public:
bool isPointInObject(const double& x1, const double& x2, const double& x3, const double& minOffset, const double& maxOffset) override;
- void scale(double delta) override;
-
+ void changeSizeByDelta(double delta) override;
+
protected:
double centerX;
double centerY;
diff --git a/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinderTest.cpp b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinderTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7bca5db9988000ecb925667a70e0615fadff5376
--- /dev/null
+++ b/src/gpu/GridGenerator/geometries/VerticalCylinder/VerticalCylinderTest.cpp
@@ -0,0 +1,57 @@
+#include <gmock/gmock.h>
+
+#include "VerticalCylinder.h"
+
+class VerticalCylinderTest : public testing::Test
+{
+protected:
+ std::array<double, 3> center = { 0.1, 0.2, 0.3 };
+ double radius = 2.0;
+ double height = 8.0;
+ VerticalCylinder cylinder = VerticalCylinder(center[0], center[1], center[2], radius, height);
+};
+
+TEST_F(VerticalCylinderTest, getCentroid)
+{
+ EXPECT_THAT(cylinder.getX1Centroid(), testing::Eq(center[0]));
+ EXPECT_THAT(cylinder.getX2Centroid(), testing::Eq(center[1]));
+ EXPECT_THAT(cylinder.getX3Centroid(), testing::Eq(center[2]));
+}
+
+TEST_F(VerticalCylinderTest, getMinimum)
+{
+ EXPECT_THAT(cylinder.getX1Minimum(), testing::Eq(-radius + center[0]));
+ EXPECT_THAT(cylinder.getX2Minimum(), testing::Eq(-radius + center[1]));
+ EXPECT_THAT(cylinder.getX3Minimum(), testing::Eq(-0.5 * height + center[2]));
+}
+
+TEST_F(VerticalCylinderTest, getMaximum)
+{
+ EXPECT_THAT(cylinder.getX1Maximum(), testing::Eq(radius + center[0]));
+ EXPECT_THAT(cylinder.getX2Maximum(), testing::Eq(radius + center[1]));
+ EXPECT_THAT(cylinder.getX3Maximum(), testing::Eq(0.5 * height + center[2]));
+}
+
+TEST_F(VerticalCylinderTest, isPointInObject)
+{
+ double epsilon = 0.0001;
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2], 0.0, 0.0));
+
+ // x
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] - radius + epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] - radius - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0] + radius - epsilon, center[1], center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0] + radius + epsilon, center[1], center[2], 0.0, 0.0));
+
+ // y
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] - radius + epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] - radius - epsilon, center[2], 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1] + radius - epsilon, center[2], 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1] + radius + epsilon, center[2], 0.0, 0.0));
+
+ // z
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] - 0.5 * height + epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] - 0.5 * height - epsilon, 0.0, 0.0));
+ EXPECT_TRUE(cylinder.isPointInObject(center[0], center[1], center[2] + 0.5 * height - epsilon, 0.0, 0.0));
+ EXPECT_FALSE(cylinder.isPointInObject(center[0], center[1], center[2] + 0.5 * height + epsilon, 0.0, 0.0));
+}
\ No newline at end of file
diff --git a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
index 78b879ea84e88e4382dfae36943bfda2696a8fb3..e087ef11f54bb20b3813bfbf9044bf4e0a7b3624 100644
--- a/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
+++ b/src/gpu/GridGenerator/grid/GridBuilder/MultipleGridBuilder.cpp
@@ -86,7 +86,7 @@ void MultipleGridBuilder::addGeometry(SPtr<Object> solidObject, uint level)
{
this->solidObject = solidObject;
auto gridShape = solidObject->clone();
- gridShape->scale(4.0);
+ gridShape->changeSizeByDelta(4.0);
this->addGrid(gridShape, level);
}
@@ -169,7 +169,7 @@ void MultipleGridBuilder::addIntermediateGridsToList(uint levelDifference, uint
{
const real scalingFactor = nodesBetweenGrids * spacings[i] * calculateDelta(levelFine);
SPtr<Object> gridShapeClone = gridShape->clone();
- gridShapeClone->scale(scalingFactor);
+ gridShapeClone->changeSizeByDelta(scalingFactor);
const auto grid = makeGrid(gridShapeClone, level++, 0);
grids.push_back(grid);
@@ -267,8 +267,12 @@ SPtr<Grid> MultipleGridBuilder::makeRotatingGrid(SPtr<VerticalCylinder> cylinder
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());
+ // #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());
SPtr<Grid> newGrid = this->makeGrid(cylinder, staggeredCoordinates[0],
staggeredCoordinates[1],