cpu/utils/axis_rotation.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 // Project include(s).
0010 #include "detray/utils/axis_rotation.hpp"
0011
0012 #include "detray/definitions/units.hpp"
0013
0014 // Detray test include(s)
0015 #include "detray/test/framework/types.hpp"
0016
0017 // GTest include(s).
0018 #include <gtest/gtest.h>
0019
0020 using namespace detray;
0021
0022 using test_algebra = test::algebra;
0023 using scalar = test::scalar;
0024 template <std::size_t ROWS, std::size_t COLS>
0025 using matrix_type = test::matrix<ROWS, COLS>;
0026
0027 static constexpr scalar isclose{1e-5f};
0028
0029 GTEST_TEST(detray_utils, axis_rotation) {
0030   const test::vector3 axis{0.f, 0.f, 3.f};
0031
0032   const test::vector3 v1{1.f, 0.f, 0.f};
0033
0034   const auto u1 = axis_rotation<test_algebra>(axis, constant<scalar>::pi_2)(v1);
0035
0036   EXPECT_NEAR(u1[0], 0.f, isclose);
0037   EXPECT_NEAR(u1[1], 1.f, isclose);
0038   EXPECT_NEAR(u1[2], 0.f, isclose);
0039
0040   matrix_type<3, 1> v2;
0041   getter::element(v2, 0, 0) = constant<scalar>::inv_sqrt2;
0042   getter::element(v2, 1, 0) = constant<scalar>::inv_sqrt2;
0043   getter::element(v2, 2, 0) = 0.f;
0044
0045   const auto u2 = axis_rotation<test_algebra>(axis, constant<scalar>::pi_4)(v2);
0046
0047   EXPECT_NEAR(getter::element(u2, 0, 0), 0.f, isclose);
0048   EXPECT_NEAR(getter::element(u2, 1, 0), 1.f, isclose);
0049   EXPECT_NEAR(getter::element(u2, 2, 0), 0.f, isclose);
0050
0051   // Counter clockswise pi/4-Rotation of (1,0,0) around (0,0,1) ->
0052   // (inv_sqrt2,inv_sqrt2,0)
0053   const test::vector3 v3{1.f, 0.f, 0.f};
0054
0055   const auto u3 = axis_rotation<test_algebra>(axis, constant<scalar>::pi_4)(v3);
0056
0057   EXPECT_NEAR(u3[0u], constant<scalar>::inv_sqrt2, isclose);
0058   EXPECT_NEAR(u3[1u], constant<scalar>::inv_sqrt2, isclose);
0059   EXPECT_NEAR(u3[2u], 0.f, isclose);
0060 }
0061
0062 GTEST_TEST(detray_utils, euler_rotation1) {
0063   euler_rotation<test_algebra> euler_rot;
0064   euler_rot.alpha = constant<scalar>::pi_2;
0065
0066   auto [x1, z1] = euler_rot();
0067
0068   EXPECT_NEAR(x1[0], 0.f, isclose);
0069   EXPECT_NEAR(x1[1], 1.f, isclose);
0070   EXPECT_NEAR(x1[2], 0.f, isclose);
0071
0072   EXPECT_NEAR(z1[0], 0.f, isclose);
0073   EXPECT_NEAR(z1[1], 0.f, isclose);
0074   EXPECT_NEAR(z1[2], 1.f, isclose);
0075
0076   euler_rot.beta = constant<scalar>::pi_2;
0077
0078   auto [x2, z2] = euler_rot();
0079   EXPECT_NEAR(x2[0], 0.f, isclose);
0080   EXPECT_NEAR(x2[1], 1.f, isclose);
0081   EXPECT_NEAR(x2[2], 0.f, isclose);
0082
0083   EXPECT_NEAR(z2[0], 1.f, isclose);
0084   EXPECT_NEAR(z2[1], 0.f, isclose);
0085   EXPECT_NEAR(z2[2], 0.f, isclose);
0086
0087   euler_rot.gamma = constant<scalar>::pi_2;
0088
0089   auto [x3, z3] = euler_rot();
0090   EXPECT_NEAR(x3[0], 0.f, isclose);
0091   EXPECT_NEAR(x3[1], 0.f, isclose);
0092   EXPECT_NEAR(x3[2], 1.f, isclose);
0093
0094   EXPECT_NEAR(z3[0], 1.f, isclose);
0095   EXPECT_NEAR(z3[1], 0.f, isclose);
0096   EXPECT_NEAR(z3[2], 0.f, isclose);
0097 }
0098
0099 GTEST_TEST(detray_utils, euler_rotation2) {
0100   euler_rotation<test_algebra> euler_rot;
0101   euler_rot.alpha = constant<scalar>::pi / 6.f;
0102   euler_rot.beta = constant<scalar>::pi_4;
0103   euler_rot.gamma = constant<scalar>::pi_2;
0104
0105   const test::vector3 v1{5.f, 7.f, 8.f};
0106   const test::vector3 v2 = euler_rot(v1);
0107
0108   auto R = matrix::zero<matrix_type<3u, 3u>>();
0109
0110   const scalar s1 = static_cast<scalar>(math::sin(euler_rot.alpha));
0111   const scalar c1 = static_cast<scalar>(math::cos(euler_rot.alpha));
0112   const scalar s2 = static_cast<scalar>(math::sin(euler_rot.beta));
0113   const scalar c2 = static_cast<scalar>(math::cos(euler_rot.beta));
0114   const scalar s3 = static_cast<scalar>(math::sin(euler_rot.gamma));
0115   const scalar c3 = static_cast<scalar>(math::cos(euler_rot.gamma));
0116
0117   // From table of https://en.wikipedia.org/wiki/Euler_angles
0118   getter::element(R, 0u, 0u) = c1 * c3 - c2 * s1 * s3;
0119   getter::element(R, 0u, 1u) = -c1 * s3 - c2 * c3 * s1;
0120   getter::element(R, 0u, 2u) = s1 * s2;
0121   getter::element(R, 1u, 0u) = c3 * s1 + c1 * c2 * s3;
0122   getter::element(R, 1u, 1u) = c1 * c2 * c3 - s1 * s3;
0123   getter::element(R, 1u, 2u) = -c1 * s2;
0124   getter::element(R, 2u, 0u) = s2 * s3;
0125   getter::element(R, 2u, 1u) = c3 * s2;
0126   getter::element(R, 2u, 2u) = c2;
0127
0128   const test::vector3 v3 = R * v1;
0129
0130   EXPECT_NEAR(v2[0u], v3[0u], isclose);
0131   EXPECT_NEAR(v2[1u], v3[1u], isclose);
0132   EXPECT_NEAR(v2[2u], v3[2u], isclose);
0133 }