Core/Detector/ProtoBinningTests.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2023 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 http://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/data/test_case.hpp>
0010 #include <boost/test/unit_test.hpp>
0011
0012 #include "Acts/Detector/ProtoBinning.hpp"
0013 #include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
0014 #include "Acts/Utilities/BinUtility.hpp"
0015
0016 using namespace Acts::Experimental;
0017
0018 BOOST_AUTO_TEST_SUITE(Detector)
0019
0020 BOOST_AUTO_TEST_CASE(ProtoBinningPlaceHolderEquidistant) {
0021   // A valid placeholder binning
0022   auto peq =
0023       ProtoBinning(Acts::binX, Acts::detail::AxisBoundaryType::Bound, 5u);
0024   BOOST_CHECK_EQUAL(peq.bins(), 5u);
0025 }
0026
0027 BOOST_AUTO_TEST_CASE(ProtoBinningEquidistant) {
0028   // An invalid binning, 0 bins given
0029   BOOST_CHECK_THROW(
0030       ProtoBinning(Acts::binX, Acts::detail::AxisBoundaryType::Bound, 15., 20.,
0031                    0),
0032       std::invalid_argument);
0033
0034   // Another invalid binning, min/max swapped
0035   BOOST_CHECK_THROW(
0036       ProtoBinning(Acts::binX, Acts::detail::AxisBoundaryType::Bound, 150., 20.,
0037                    10),
0038       std::invalid_argument);
0039
0040   // A valid binning
0041   auto eq = ProtoBinning(Acts::binX, Acts::detail::AxisBoundaryType::Bound, 0.,
0042                          10., 5u);
0043
0044   std::vector<Acts::ActsScalar> reference = {0., 2., 4., 6., 8., 10.};
0045   BOOST_CHECK_EQUAL(eq.bins(), 5u);
0046   BOOST_CHECK_EQUAL(eq.binValue, Acts::binX);
0047   BOOST_CHECK(eq.axisType == Acts::detail::AxisType::Equidistant);
0048   BOOST_CHECK(eq.boundaryType == Acts::detail::AxisBoundaryType::Bound);
0049   BOOST_CHECK_EQUAL_COLLECTIONS(eq.edges.begin(), eq.edges.end(),
0050                                 reference.begin(), reference.end());
0051 }
0052
0053 BOOST_AUTO_TEST_CASE(ProtoBinningVariable) {
0054   // An invalid binning, edge size < 2u
0055   std::vector<Acts::ActsScalar> iedges = {12.};
0056   BOOST_CHECK_THROW(
0057       ProtoBinning(Acts::binX, Acts::detail::AxisBoundaryType::Bound, iedges),
0058       std::invalid_argument);
0059
0060   // A valid binning
0061   std::vector<Acts::ActsScalar> varEdges = {0., 12., 13., 15., 20.};
0062   auto var =
0063       ProtoBinning(Acts::binX, Acts::detail::AxisBoundaryType::Bound, varEdges);
0064
0065   BOOST_CHECK_EQUAL(var.bins(), 4u);
0066   BOOST_CHECK_EQUAL(var.binValue, Acts::binX);
0067   BOOST_CHECK(var.axisType == Acts::detail::AxisType::Variable);
0068   BOOST_CHECK(var.boundaryType == Acts::detail::AxisBoundaryType::Bound);
0069   BOOST_CHECK_EQUAL_COLLECTIONS(var.edges.begin(), var.edges.end(),
0070                                 varEdges.begin(), varEdges.end());
0071 }
0072
0073 BOOST_AUTO_TEST_CASE(BinningDescriptionFromAndToBinUtility) {
0074   // A valid binning
0075   Acts::BinUtility bUtility(5u, 0., 10., Acts::open, Acts::binR);
0076   std::vector<float> edges = {-M_PI, 0.1, M_PI};
0077   bUtility += Acts::BinUtility(edges, Acts::closed, Acts::binPhi);
0078
0079   auto bDescription = BinningDescription::fromBinUtility(bUtility);
0080
0081   BOOST_CHECK_EQUAL(bDescription.binning.size(), 2u);
0082
0083   // Test the first entry
0084   BOOST_CHECK_EQUAL(bDescription.binning[0].bins(), 5u);
0085   BOOST_CHECK_EQUAL(bDescription.binning[0].binValue, Acts::binR);
0086   BOOST_CHECK(bDescription.binning[0].axisType ==
0087               Acts::detail::AxisType::Equidistant);
0088   BOOST_CHECK(bDescription.binning[0].boundaryType ==
0089               Acts::detail::AxisBoundaryType::Bound);
0090   BOOST_CHECK_EQUAL(bDescription.binning[0].edges.size(), 6u);
0091
0092   // Check the second entry
0093   BOOST_CHECK_EQUAL(bDescription.binning[1].bins(), 2u);
0094   BOOST_CHECK_EQUAL(bDescription.binning[1].binValue, Acts::binPhi);
0095   BOOST_CHECK(bDescription.binning[1].axisType ==
0096               Acts::detail::AxisType::Variable);
0097   BOOST_CHECK(bDescription.binning[1].boundaryType ==
0098               Acts::detail::AxisBoundaryType::Closed);
0099   BOOST_CHECK_EQUAL(bDescription.binning[1].edges.size(), 3u);
0100
0101   // Round-trip
0102   auto binUtility = bDescription.toBinUtility();
0103   BOOST_CHECK_EQUAL(binUtility.binningData().size(), 2u);
0104   BOOST_CHECK_EQUAL(binUtility.binningData()[0].bins(), 5u);
0105   BOOST_CHECK_EQUAL(binUtility.binningData()[1].bins(), 2u);
0106   BOOST_CHECK_EQUAL(binUtility.binningData()[1].boundaries().size(), 3u);
0107   CHECK_CLOSE_ABS(binUtility.binningData()[1].boundaries()[0], -M_PI, 1e-5);
0108   CHECK_CLOSE_ABS(binUtility.binningData()[1].boundaries()[1], 0.1, 1e-4);
0109 }
0110
0111 BOOST_AUTO_TEST_SUITE_END()