Core/Utilities/BinUtilityTests.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 #include <boost/test/unit_test.hpp>
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Utilities/AxisDefinitions.hpp"
0013 #include "Acts/Utilities/BinUtility.hpp"
0014 #include "Acts/Utilities/BinningType.hpp"
0015 #include "Acts/Utilities/Diagnostics.hpp"
0016 #include "Acts/Utilities/IAxis.hpp"
0017 #include "Acts/Utilities/IMultiAxis.hpp"
0018 #include "Acts/Utilities/ProtoAxis.hpp"
0019
0020 #include <array>
0021 #include <cmath>
0022 #include <cstddef>
0023 #include <numbers>
0024 #include <utility>
0025 #include <vector>
0026
0027 using namespace Acts;
0028
0029 namespace ActsTests {
0030
0031 BOOST_AUTO_TEST_SUITE(UtilitiesSuite)
0032
0033 // OPEN - equidistant binning tests
0034 BOOST_AUTO_TEST_CASE(BinUtility_equidistant_binning) {
0035   Vector3 xyzPosition(1.5, 2.5, 3.5);
0036   Vector3 edgePosition(0.5, 0.5, 0.5);
0037
0038   // | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0039   BinUtility xUtil_eq(10, 0., 10., open, AxisDirection::AxisX);
0040   BinUtility yUtil_eq(10, 0., 10., open, AxisDirection::AxisY);
0041   BinUtility zUtil_eq(10, 0., 10., open, AxisDirection::AxisZ);
0042   BOOST_CHECK_EQUAL(xUtil_eq.bins(), std::size_t{10});
0043   // make it 2-dim
0044   BinUtility xyUtil_eq(10, 0., 10., open, AxisDirection::AxisX);
0045   xyUtil_eq += yUtil_eq;
0046   BOOST_CHECK_EQUAL(xyUtil_eq.bins(), 100u);
0047   // make it 3-dim
0048   BinUtility xyzUtil_eq(xyUtil_eq);
0049   xyzUtil_eq += zUtil_eq;
0050   BOOST_CHECK_EQUAL(xyzUtil_eq.bins(), 1000u);
0051   // check the dimensions
0052   BOOST_CHECK_EQUAL(xUtil_eq.dimensions(), 1u);
0053   BOOST_CHECK_EQUAL(xyUtil_eq.dimensions(), 2u);
0054   BOOST_CHECK_EQUAL(xyzUtil_eq.dimensions(), 3u);
0055
0056   // check equality operator
0057   BinUtility xUtil_eq_copy(10, 0., 10., open, AxisDirection::AxisX);
0058   BOOST_CHECK_EQUAL(xUtil_eq_copy, xUtil_eq);
0059   BOOST_CHECK_NE(yUtil_eq, xUtil_eq);
0060
0061   // bin triples and clusters
0062   auto xTriple = xUtil_eq.binTriple(xyzPosition);
0063   auto xyTriple = xyUtil_eq.binTriple(xyzPosition);
0064   auto xyzTriple = xyzUtil_eq.binTriple(xyzPosition);
0065
0066   BOOST_CHECK_EQUAL(xTriple[0], 1u);
0067   BOOST_CHECK_EQUAL(xTriple[1], 0u);
0068   BOOST_CHECK_EQUAL(xTriple[2], 0u);
0069
0070   BOOST_CHECK_EQUAL(xyTriple[0], 1u);
0071   BOOST_CHECK_EQUAL(xyTriple[1], 2u);
0072   BOOST_CHECK_EQUAL(xyTriple[2], 0u);
0073
0074   BOOST_CHECK_EQUAL(xyzTriple[0], 1u);
0075   BOOST_CHECK_EQUAL(xyzTriple[1], 2u);
0076   BOOST_CHECK_EQUAL(xyzTriple[2], 3u);
0077 }
0078
0079 // OPEN - equidistant binning tests
0080 BOOST_AUTO_TEST_CASE(BinUtility_arbitrary_binning) {
0081   std::vector<float> bvalues = {-5., 0., 1., 1.1, 8.};
0082   BinUtility xUtil(bvalues, open, AxisDirection::AxisX);
0083
0084   // Underflow
0085   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(-6., 0., 0.)), 0u);
0086   // Bin 0
0087   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(-4., 0., 0.)), 0u);
0088   // Bin 1
0089   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(0.5, 0., 0.)), 1u);
0090   // Bin 2
0091   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(1.05, 0., 0.)), 2u);
0092   // Bin 3
0093   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(4., 0., 0.)), 3u);
0094   // Overflow
0095   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(9., 0., 0.)), 3u);
0096 }
0097
0098 // OPEN - local to global transform test
0099 BOOST_AUTO_TEST_CASE(BinUtility_transform) {
0100   Transform3 transform_LtoG = Transform3::Identity();
0101   transform_LtoG = transform_LtoG * Translation3(0., 0., -50);
0102   transform_LtoG =
0103       transform_LtoG * AngleAxis3(std::numbers::pi / 4., Vector3(0, 0, 1));
0104
0105   Transform3 transform_GtoL = transform_LtoG.inverse();
0106
0107   BinUtility rUtil(10, 0., 100., open, AxisDirection::AxisR);
0108   BinUtility phiUtil(10, -std::numbers::pi, std::numbers::pi, closed,
0109                      AxisDirection::AxisPhi);
0110   BinUtility zUtil(10, -100., 100., open, AxisDirection::AxisZ);
0111
0112   BinUtility noTranform;
0113   noTranform += rUtil;
0114   noTranform += phiUtil;
0115   noTranform += zUtil;
0116
0117   BinUtility withTranform(transform_LtoG);
0118   withTranform += rUtil;
0119   withTranform += phiUtil;
0120   withTranform += zUtil;
0121
0122   Vector3 pos1(0, 0, 0);
0123   Vector3 pos2(60, 0, 0);
0124   Vector3 pos3(34, std::numbers::pi / 2., 0);
0125   Vector3 pos4(0, 0, -80);
0126   Vector3 pos5(80, -std::numbers::pi / 4., 50);
0127
0128   for (int i = 0; i < 3; i++) {
0129     BOOST_CHECK_EQUAL(withTranform.bin(pos1, i),
0130                       noTranform.bin(transform_GtoL * pos1, i));
0131     BOOST_CHECK_EQUAL(withTranform.bin(pos2, i),
0132                       noTranform.bin(transform_GtoL * pos2, i));
0133     BOOST_CHECK_EQUAL(withTranform.bin(pos3, i),
0134                       noTranform.bin(transform_GtoL * pos3, i));
0135     BOOST_CHECK_EQUAL(withTranform.bin(pos4, i),
0136                       noTranform.bin(transform_GtoL * pos4, i));
0137     BOOST_CHECK_EQUAL(withTranform.bin(pos5, i),
0138                       noTranform.bin(transform_GtoL * pos5, i));
0139   }
0140 }
0141
0142 BOOST_AUTO_TEST_CASE(BinUtility_from_ProtoAxis) {
0143   using enum AxisDirection;
0144   using enum AxisBoundaryType;
0145
0146   // The DirectedProtoAxis based constructors are deprecated but still
0147   // covered here
0148   ACTS_PUSH_IGNORE_DEPRECATED()
0149   DirectedProtoAxis epabX(AxisX, Bound, 0.0, 1.0, 10);
0150   BinUtility buX(epabX);
0151   BOOST_CHECK_EQUAL(buX.bins(), std::size_t{10});
0152   BOOST_CHECK_EQUAL(buX.dimensions(), std::size_t{1});
0153
0154   DirectedProtoAxis epabY(AxisY, Bound, 0.0, 1.0, 10);
0155   BinUtility buXY({epabX, epabY});
0156   BOOST_CHECK_EQUAL(buXY.bins(), std::size_t{100});
0157   BOOST_CHECK_EQUAL(buXY.dimensions(), std::size_t{2});
0158   ACTS_POP_IGNORE_DEPRECATED()
0159 }
0160
0161 BOOST_AUTO_TEST_CASE(BinUtility_from_IAxis) {
0162   using enum AxisDirection;
0163   using enum AxisBoundaryType;
0164
0165   auto axisX = IAxis::createEquidistant(Bound, 0.0, 1.0, 10, AxisX);
0166   BinUtility buX(*axisX);
0167   BOOST_CHECK_EQUAL(buX.bins(), std::size_t{10});
0168   BOOST_CHECK_EQUAL(buX.dimensions(), std::size_t{1});
0169
0170   auto axisY = IAxis::createEquidistant(Bound, 0.0, 1.0, 10, AxisY);
0171   auto multiAxis = IMultiAxis::create(*axisX, *axisY);
0172   BinUtility buXY(*multiAxis);
0173   BOOST_CHECK_EQUAL(buXY.bins(), std::size_t{100});
0174   BOOST_CHECK_EQUAL(buXY.dimensions(), std::size_t{2});
0175 }
0176
0177 BOOST_AUTO_TEST_SUITE_END()
0178
0179 }  // namespace ActsTests