From a031a008e606607f492c518fafee09c94361b8eb Mon Sep 17 00:00:00 2001
From: Anna Wellmann <a.wellmann@tu-braunschweig.de>
Date: Thu, 28 Sep 2023 12:11:42 +0000
Subject: [PATCH] Test function for rotation
---
src/basics/tests/testUtilities.h | 27 ++
src/basics/tests/testUtilitiesTest.cpp | 13 +
.../CoordinateTransformation.h | 36 +-
.../CoordinateTransformationTest.h | 363 +++++++++++++++---
4 files changed, 354 insertions(+), 85 deletions(-)
create mode 100644 src/basics/tests/testUtilitiesTest.cpp
diff --git a/src/basics/tests/testUtilities.h b/src/basics/tests/testUtilities.h
index ed7f88d1b..3de25bbf4 100644
--- a/src/basics/tests/testUtilities.h
+++ b/src/basics/tests/testUtilities.h
@@ -2,6 +2,7 @@
#define TESTUTILITIES_H
#include <gmock/gmock.h>
+#include <basics/DataTypes.h>
inline auto RealEq = [](auto value) {
#ifdef VF_DOUBLE_ACCURACY
@@ -19,9 +20,35 @@ inline auto RealNear = [](auto value, auto max_abs_error) {
#endif
};
+namespace
+{
+__inline__ bool isEqualWithAccuracy(real number, real expected, real accuracy)
+{
+ return number > (expected - accuracy) && number < (expected + accuracy);
+}
+} // namespace
+
namespace testingVF
{
+MATCHER_P2(RealNearForContainer, expectedContainer, accuracy, "")
+{
+ if (arg.size() != expectedContainer.size()) {
+ std::cout << "The checked container does not have the same size as the expected container.\n" << std::endl;
+ return false;
+ }
+
+ for (int i = 0; i < arg.size(); i++) {
+ if (!isEqualWithAccuracy(arg[i], expectedContainer[i], accuracy)) {
+ std::cout << "First mismatching element at index " << i << ": The actual element " << std::to_string(arg[i])
+ << " is not near the expected element " << std::to_string(expectedContainer[i])
+ << " (difference = " << std::to_string(expectedContainer[i] - arg[i]) << ").\n";
+ return false;
+ }
+ }
+ return true;
+}
+
__inline__ void captureStdOut()
{
testing::internal::CaptureStdout();
diff --git a/src/basics/tests/testUtilitiesTest.cpp b/src/basics/tests/testUtilitiesTest.cpp
new file mode 100644
index 000000000..b6f103869
--- /dev/null
+++ b/src/basics/tests/testUtilitiesTest.cpp
@@ -0,0 +1,13 @@
+#include "testUtilities.h"
+
+TEST(isEqualWithAccuracy, test)
+{
+ const real accuracy = 1.0;
+ const real expected = 0.0;
+
+ EXPECT_TRUE(isEqualWithAccuracy( 0.0, expected, accuracy));
+ EXPECT_TRUE(isEqualWithAccuracy( 0.999999, expected, accuracy));
+ EXPECT_TRUE(isEqualWithAccuracy( -0.999999, expected, accuracy));
+ EXPECT_FALSE(isEqualWithAccuracy( 1.000001, expected, accuracy));
+ EXPECT_FALSE(isEqualWithAccuracy( -1.000001, expected, accuracy));
+}
diff --git a/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformation.h b/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformation.h
index b6785fb28..727864752 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformation.h
+++ b/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformation.h
@@ -30,7 +30,7 @@ __inline__ __host__ __device__ void rotateDataFromRotatingToGlobal(real &datumX,
datumZ = datumZTemp;
}
-__inline__ __device__ void transformRotatingToGlobal(real &globalX, real &globalY, real &globalZ, real localX, real localY,
+__inline__ __host__ __device__ void transformRotatingToGlobal(real &globalX, real &globalY, real &globalZ, real localX, real localY,
real localZ, real centerCoordX, real centerCoordY, real centerCoordZ,
real angleX, real angleY, real angleZ)
{
@@ -38,20 +38,7 @@ __inline__ __device__ void transformRotatingToGlobal(real &globalX, real &global
globalY = localY;
globalZ = localZ;
- // rotate
- if (angleX != 0) {
- // rotate in x
- globalY = localY * cos(angleX) - localZ * sin(angleX);
- globalZ = localY * sin(angleX) + localZ * cos(angleX);
- } else if (angleY != 0) {
- // rotate in y
- globalX = localX * cos(angleY) + localZ * sin(angleY);
- globalZ = -localX * sin(angleY) + localZ * cos(angleY);
- } else if (angleZ != 0) {
- // rotate in z
- globalX = localX * cos(angleZ) - localY * sin(angleZ);
- globalY = localX * sin(angleZ) + localY * cos(angleZ);
- }
+ rotateDataFromRotatingToGlobal(globalX, globalY, globalZ, angleX, angleY, angleZ);
// translate
globalX += centerCoordX;
@@ -60,7 +47,7 @@ __inline__ __device__ void transformRotatingToGlobal(real &globalX, real &global
}
-__inline__ __device__ void rotateDataFromGlobalToRotating(real &datumX, real &datumY, real &datumZ, real angleX,
+__inline__ __host__ __device__ void rotateDataFromGlobalToRotating(real &datumX, real &datumY, real &datumZ, real angleX,
real angleY, real angleZ)
{
real datumXTemp = datumX;
@@ -83,7 +70,7 @@ __inline__ __device__ void rotateDataFromGlobalToRotating(real &datumX, real &da
datumZ = datumZTemp;
}
-__inline__ __device__ void transformGlobalToRotating(real &rotatingX, real &rotatingY, real &rotatingZ, real globalX,
+__inline__ __host__ __device__ void transformGlobalToRotating(real &rotatingX, real &rotatingY, real &rotatingZ, real globalX,
real globalY, real globalZ, real centerCoordX, real centerCoordY,
real centerCoordZ, real angleX, real angleY, real angleZ)
{
@@ -97,20 +84,7 @@ __inline__ __device__ void transformGlobalToRotating(real &rotatingX, real &rota
rotatingY = globalY;
rotatingZ = globalZ;
- // rotate
- if (angleX != 0) {
- // rotate in x
- rotatingY = globalY * cos(angleX) + globalZ * sin(angleX);
- rotatingZ = -globalY * sin(angleX) + globalZ * cos(angleX);
- } else if (angleY != 0) {
- // rotate in y
- rotatingX = globalX * cos(angleY) - globalZ * sin(angleY);
- rotatingZ = globalX * sin(angleY) + globalZ * cos(angleY);
- } else if (angleZ != 0) {
- // rotate in z
- rotatingX = globalX * cos(angleZ) + globalY * sin(angleZ);
- rotatingY = -globalX * sin(angleZ) + globalY * cos(angleZ);
- }
+ rotateDataFromGlobalToRotating(rotatingX, rotatingY, rotatingZ, angleX, angleY, angleZ);
}
#endif
\ No newline at end of file
diff --git a/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformationTest.h b/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformationTest.h
index af2b06bf0..351643546 100644
--- a/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformationTest.h
+++ b/src/gpu/VirtualFluids_GPU/LBM/GPUHelperFunctions/CoordinateTransformationTest.h
@@ -2,54 +2,7 @@
#include "CoordinateTransformation.h"
#include "tests/testUtilities.h"
-bool isEqualWithAccuracy(real number, real expected, real accuracy)
-{
- if (number > (expected - accuracy) && number < (expected + accuracy)) return true;
- return false;
-}
-
-MATCHER_P2(RealNearForContainer, containerExpected, accuracy, "")
-{
- if (arg.size() != containerExpected.size()) {
- std::cout << "The checked container does not have the same size as the expected container.\n" << std::endl;
- return false;
- }
-
- for (int i = 0; i < arg.size(); i++) {
- if (!isEqualWithAccuracy(arg[i], containerExpected[i], accuracy)) {
- std::cout << "First mismatching element at index " << i << ": The actual element " << std::to_string(arg[i])
- << " is not near the expected element " << std::to_string(containerExpected[i]) << ".\n";
- return false;
- }
- }
- return true;
-}
-
-MATCHER_P2(NearForContainer, containerExpected, matcher, "")
-{
- if (arg.size() != containerExpected.size()) {
- std::cout << "The checked container does not have the same size as the expected container.\n" << std::endl;
- return false;
- }
-
- for (int i = 0; i < arg.size(); i++) {
- testing::ExplainMatchResult(matcher, arg[i], result_listener);
- }
- return true;
-}
-
-
-TEST(isEqualWithAccuracy, test)
-{
- const real accuracy = 1.0;
- const real expected = 0.0;
-
- EXPECT_TRUE(isEqualWithAccuracy( 0.0, expected, accuracy));
- EXPECT_TRUE(isEqualWithAccuracy( 0.999999, expected, accuracy));
- EXPECT_TRUE(isEqualWithAccuracy( -0.999999, expected, accuracy));
- EXPECT_FALSE(isEqualWithAccuracy( 1.000001, expected, accuracy));
- EXPECT_FALSE(isEqualWithAccuracy( -1.000001, expected, accuracy));
-}
+using namespace testingVF;
class CoordinateTransformationTest : public testing::Test
{
@@ -57,8 +10,9 @@ protected:
real datumX = 1.;
real datumY = 2.;
real datumZ = 3.;
- std::array<real, 3> data = { 1., 2., 3. };
+ std::array<real, 3> data = { datumX, datumY, datumZ };
std::array<real, 3> dataBeforeTransformation = data;
+ std::array<real, 3> centerCoordinates = {0.0, 0.0, 0.0};
};
TEST_F(CoordinateTransformationTest, rotatingToGlobal_zeroRotationAndTranslation)
@@ -66,36 +20,337 @@ TEST_F(CoordinateTransformationTest, rotatingToGlobal_zeroRotationAndTranslation
const std::array<real, 3> angles = { 0.0, 0.0, 0.0 };
rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
EXPECT_THAT(data, testing::Eq(dataBeforeTransformation));
-}
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, testing::Eq(dataBeforeTransformation));
+}
-TEST_F(CoordinateTransformationTest, rotatingToGlobal_twoPiRotation)
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_twoPiRotationX)
{
const std::array<real, 3> angles = { c2Pi, 0.0, 0.0 };
rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
}
-TEST_F(CoordinateTransformationTest, rotatingToGlobal_piRotation)
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_piRotationX)
{
const std::array<real, 3> angles = { cPi, 0.0, 0.0 };
rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
const std::array<real, 3> expected = { datumX, -datumY, -datumZ };
EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
}
-TEST_F(CoordinateTransformationTest, rotatingToGlobal_piHalfRotation)
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_piHalfRotationX)
{
const std::array<real, 3> angles = { real(0.5 * cPi), 0.0, 0.0 };
rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
const std::array<real, 3> expected = { datumX, -datumZ, datumY };
EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
}
-TEST_F(CoordinateTransformationTest, rotatingToGlobal_minusPiHalfRotation)
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_minusPiHalfRotationX)
{
const std::array<real, 3> angles = { real(-0.5 * cPi), 0.0, 0.0 };
rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
const std::array<real, 3> expected = { datumX, datumZ, -datumY };
EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_twoPiRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, c2Pi, 0.0 };
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_piRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, cPi, 0.0 };
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumX, datumY, -datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_piHalfRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, real(0.5 * cPi), 0.0 };
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { datumZ, datumY, -datumX };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_minusPiHalfRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, real(-0.5 * cPi), 0.0 };
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumZ, datumY, datumX };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_twoPiRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, c2Pi};
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_piRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, cPi };
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumX, -datumY, datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_piHalfRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, real(0.5 * cPi)};
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumY, datumX, datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, rotatingToGlobal_minusPiHalfRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, real(-0.5 * cPi)};
+ rotateDataFromRotatingToGlobal(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { datumY, -datumX, datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformRotatingToGlobal(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+
+
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// global to rotating
+
+TEST_F(CoordinateTransformationTest, globalToRotating_zeroRotationAndTranslation)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, testing::Eq(dataBeforeTransformation));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, testing::Eq(dataBeforeTransformation));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_twoPiRotationX)
+{
+ const std::array<real, 3> angles = { c2Pi, 0.0, 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_piRotationX)
+{
+ const std::array<real, 3> angles = { cPi, 0.0, 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { datumX, -datumY, -datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_piHalfRotationX)
+{
+ const std::array<real, 3> angles = { real(0.5 * cPi), 0.0, 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { datumX, datumZ, -datumY };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_minusPiHalfRotationX)
+{
+ const std::array<real, 3> angles = { real(-0.5 * cPi), 0.0, 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { datumX, -datumZ, datumY };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_twoPiRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, c2Pi, 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_piRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, cPi, 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumX, datumY, -datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_piHalfRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, real(0.5 * cPi), 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumZ, datumY, datumX };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_minusPiHalfRotationY)
+{
+ const std::array<real, 3> angles = { 0.0, real(-0.5 * cPi), 0.0 };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { datumZ, datumY, -datumX };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_twoPiRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, c2Pi};
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(dataBeforeTransformation, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_piRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, cPi };
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumX, -datumY, datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_piHalfRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, real(0.5 * cPi)};
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { datumY, -datumX, datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+}
+
+TEST_F(CoordinateTransformationTest, globalToRotating_minusPiHalfRotationZ)
+{
+ const std::array<real, 3> angles = { 0.0, 0.0, real(-0.5 * cPi)};
+ rotateDataFromGlobalToRotating(data[0], data[1], data[2], angles[0], angles[1], angles[2]);
+ const std::array<real, 3> expected = { -datumY, datumX, datumZ };
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
+
+ transformGlobalToRotating(data[0], data[1], data[2], dataBeforeTransformation[0], dataBeforeTransformation[1],
+ dataBeforeTransformation[2], centerCoordinates[0], centerCoordinates[1], centerCoordinates[2],
+ angles[0], angles[1], angles[2]);
+ EXPECT_THAT(data, RealNearForContainer(expected, 1e-6));
}
--
GitLab