Core/Utilities/ProtoAxisTests.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/data/test_case.hpp>
0010 #include <boost/test/unit_test.hpp>
0011
0012 #include "Acts/Utilities/Axis.hpp"
0013 #include "Acts/Utilities/AxisDefinitions.hpp"
0014 #include "Acts/Utilities/ProtoAxis.hpp"
0015 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0016
0017 namespace ActsTests {
0018
0019 BOOST_AUTO_TEST_SUITE(UtilitiesSuite)
0020
0021 BOOST_AUTO_TEST_CASE(EquidistantProtoAxis) {
0022   using enum Acts::AxisBoundaryType;
0023   using enum Acts::AxisType;
0024
0025   // Bound, equidistant axis
0026   Acts::ProtoAxis epab(Bound, 0.0, 1.0, 10);
0027
0028   // Direct access
0029   BOOST_CHECK(!epab.isAutorange());
0030
0031   // Access via IAxis
0032   BOOST_CHECK(epab.getAxis().isEquidistant());
0033
0034   BOOST_CHECK(!epab.getAxis().isVariable());
0035
0036   auto edges = epab.getAxis().getBinEdges();
0037   BOOST_CHECK_EQUAL(edges.size(), 11);
0038
0039   BOOST_CHECK_EQUAL(epab.getAxis().getType(), Equidistant);
0040
0041   BOOST_CHECK_EQUAL(epab.getAxis().getBoundaryType(), Bound);
0042
0043   BOOST_CHECK_EQUAL(epab.getAxis().getNBins(), 10);
0044
0045   CHECK_CLOSE_ABS(epab.getAxis().getMin(), 0.0, 1e-15);
0046
0047   CHECK_CLOSE_ABS(epab.getAxis().getMax(), 1.0, 1e-15);
0048
0049   std::string rString = "ProtoAxis: 10 bins, equidistant within [0, 1]";
0050   std::string oString = epab.toString();
0051   BOOST_CHECK_EQUAL(rString, oString);
0052
0053   // Test copy constructor
0054   Acts::ProtoAxis epabCopy(epab);
0055   BOOST_CHECK_EQUAL(epabCopy.isAutorange(), epab.isAutorange());
0056   BOOST_CHECK(epabCopy.getAxis() == epab.getAxis());
0057
0058   // Test Assignment operator
0059   Acts::ProtoAxis epabAssign(Bound, 0.0, 50.0, 20);
0060   epabAssign = epab;
0061   BOOST_CHECK_EQUAL(epabAssign.isAutorange(), epab.isAutorange());
0062   BOOST_CHECK(epabAssign.getAxis() == epab.getAxis());
0063
0064   // Create a grid from a single proto axis
0065   auto grid1D = Acts::makeGrid<double>(epab);
0066   BOOST_CHECK(grid1D != nullptr);
0067   BOOST_CHECK_EQUAL(grid1D->axes().size(), 1);
0068   auto axis1D =
0069       dynamic_cast<const Acts::Axis<Acts::AxisType::Equidistant, Bound>*>(
0070           grid1D->axes().front());
0071   BOOST_CHECK(axis1D != nullptr);
0072
0073   // Open, equidistant axis
0074   Acts::ProtoAxis epao(Open, 0., 2.0, 10.);
0075   BOOST_CHECK_EQUAL(epao.getAxis().getBoundaryType(), Open);
0076
0077   // Create a 2D grid from a two proto axes
0078   auto grid2D = Acts::makeGrid<double>(epab, epao);
0079   BOOST_CHECK(grid2D != nullptr);
0080   auto grid2Daxes = grid2D->axes();
0081   BOOST_CHECK_EQUAL(grid2Daxes.size(), 2);
0082   auto axis2D1 =
0083       dynamic_cast<const Acts::Axis<Acts::AxisType::Equidistant, Bound>*>(
0084           grid2Daxes[0]);
0085   BOOST_CHECK(axis2D1 != nullptr);
0086   auto axis2D2 =
0087       dynamic_cast<const Acts::Axis<Acts::AxisType::Equidistant, Open>*>(
0088           grid2Daxes[1]);
0089   BOOST_CHECK(axis2D2 != nullptr);
0090
0091   // Invalid constructor, min > max
0092   BOOST_CHECK_THROW(Acts::ProtoAxis(Bound, 1.0, 0.0, 10),
0093                     std::invalid_argument);
0094
0095   // Invalid constructor, nbins < 1
0096   BOOST_CHECK_THROW(Acts::ProtoAxis(Bound, 0.0, 1.0, 0), std::invalid_argument);
0097 }
0098
0099 BOOST_AUTO_TEST_CASE(AutorangeProtoAxis) {
0100   using enum Acts::AxisBoundaryType;
0101   using enum Acts::AxisType;
0102
0103   // Bound, equidistant axis, autorange
0104   Acts::ProtoAxis epa(Bound, 10);
0105
0106   // Direct access
0107   BOOST_CHECK(epa.isAutorange());
0108
0109   // Access via IAxis
0110   BOOST_CHECK(epa.getAxis().isEquidistant());
0111
0112   BOOST_CHECK(!epa.getAxis().isVariable());
0113
0114   BOOST_CHECK_EQUAL(epa.getAxis().getType(), Equidistant);
0115
0116   BOOST_CHECK_EQUAL(epa.getAxis().getBoundaryType(), Bound);
0117
0118   BOOST_CHECK_EQUAL(epa.getAxis().getNBins(), 10);
0119
0120   std::string rString =
0121       "ProtoAxis: 10 bins, equidistant within automatic range";
0122   std::string oString = epa.toString();
0123   BOOST_CHECK_EQUAL(rString, oString);
0124
0125   // Test copy constructor
0126   Acts::ProtoAxis epaCopy(epa);
0127   BOOST_CHECK_EQUAL(epaCopy.isAutorange(), epa.isAutorange());
0128   BOOST_CHECK(epaCopy.getAxis() == epa.getAxis());
0129
0130   // Test Assignment operator
0131   Acts::ProtoAxis epaAssign(Bound, 0.0, 50.0, 20);
0132   epaAssign = epa;
0133   BOOST_CHECK_EQUAL(epaAssign.isAutorange(), epa.isAutorange());
0134   BOOST_CHECK(epaAssign.getAxis() == epa.getAxis());
0135
0136   // Invalid 1D grid construction with autorange axis
0137   BOOST_CHECK_THROW(Acts::makeGrid<double>(epa), std::invalid_argument);
0138
0139   // Invalid 2D grid construction with autorange axis
0140   Acts::ProtoAxis epao(Open, 0., 2.0, 10.);
0141   BOOST_CHECK_THROW(Acts::makeGrid<double>(epao, epa), std::invalid_argument);
0142   BOOST_CHECK_THROW(Acts::makeGrid<double>(epa, epao), std::invalid_argument);
0143
0144   // Set the range now
0145   epa.setRange(0.0, 20.0);
0146   BOOST_CHECK(!epa.isAutorange());
0147
0148   // 1D Grid consstruction works now
0149   BOOST_CHECK_NO_THROW(Acts::makeGrid<double>(epa));
0150
0151   // 2D Grid consstruction works now
0152   BOOST_CHECK_NO_THROW(Acts::makeGrid<double>(epa, epao));
0153
0154   // Invalid setRange, min > max
0155   BOOST_CHECK_THROW(epa.setRange(20.0, 0.0), std::invalid_argument);
0156 }
0157
0158 BOOST_AUTO_TEST_CASE(VariableProtoAxis) {
0159   using enum Acts::AxisBoundaryType;
0160   using enum Acts::AxisType;
0161
0162   // Bound, variable axis
0163   Acts::ProtoAxis vpab(Bound, {0.0, 1.0, 10});
0164
0165   // Direct access
0166   BOOST_CHECK(!vpab.isAutorange());
0167
0168   // Access via IAxis
0169   BOOST_CHECK(!vpab.getAxis().isEquidistant());
0170
0171   BOOST_CHECK(vpab.getAxis().isVariable());
0172
0173   auto edges = vpab.getAxis().getBinEdges();
0174   BOOST_CHECK_EQUAL(edges.size(), 3);
0175
0176   BOOST_CHECK_EQUAL(vpab.getAxis().getType(), Variable);
0177
0178   BOOST_CHECK_EQUAL(vpab.getAxis().getBoundaryType(), Bound);
0179
0180   BOOST_CHECK_EQUAL(vpab.getAxis().getNBins(), 2);
0181
0182   CHECK_CLOSE_ABS(vpab.getAxis().getMin(), 0.0, 1e-15);
0183
0184   CHECK_CLOSE_ABS(vpab.getAxis().getMax(), 10.0, 1e-15);
0185
0186   std::string rString = "ProtoAxis: 2 bins, variable within [0, 10]";
0187   std::string oString = vpab.toString();
0188   BOOST_CHECK_EQUAL(rString, oString);
0189
0190   // Test copy constructor
0191   Acts::ProtoAxis vpabCopy(vpab);
0192   BOOST_CHECK_EQUAL(vpabCopy.isAutorange(), vpab.isAutorange());
0193   BOOST_CHECK(vpabCopy.getAxis() == vpab.getAxis());
0194
0195   // Test Assignment operator
0196   Acts::ProtoAxis vpabAssign(Bound, 0.0, 50.0, 20);
0197   vpabAssign = vpab;
0198   BOOST_CHECK_EQUAL(vpabAssign.isAutorange(), vpab.isAutorange());
0199   BOOST_CHECK(vpabAssign.getAxis() == vpab.getAxis());
0200
0201   // Set Range for variable
0202   vpab.setRange(0.5, 9.5);
0203   // Bins stay the same. min/max update
0204   BOOST_CHECK_EQUAL(vpab.getAxis().getNBins(), 2);
0205   CHECK_CLOSE_ABS(vpab.getAxis().getMin(), 0.5, 1e-15);
0206   CHECK_CLOSE_ABS(vpab.getAxis().getMax(), 9.5, 1e-15);
0207
0208   // Invalid constructor, min > max
0209   BOOST_CHECK_THROW(Acts::ProtoAxis(Bound, std::vector<double>{2.}),
0210                     std::invalid_argument);
0211
0212   // Invalid constructor, nbins < 1
0213   BOOST_CHECK_THROW(Acts::ProtoAxis(Bound, {3., 2., 1}), std::invalid_argument);
0214 }
0215
0216 BOOST_AUTO_TEST_CASE(DirectedProtoAxisOfAllSorts) {
0217   using enum Acts::AxisBoundaryType;
0218   using enum Acts::AxisDirection;
0219   using enum Acts::AxisType;
0220
0221   // Bound, variable axis - directed at x
0222   Acts::DirectedProtoAxis vpab(AxisX, Bound, {0.0, 1.0, 10});
0223   BOOST_CHECK(vpab.getAxisDirection() == AxisX);
0224   std::string rvString =
0225       "DirectedProtoAxis: 2 bins in AxisX, variable within [0, 10]";
0226   std::string ovString = vpab.toString();
0227   BOOST_CHECK_EQUAL(rvString, ovString);
0228
0229   // Bound, equidistant axis, autorange - directed at y
0230   Acts::DirectedProtoAxis epa(AxisY, Bound, 10);
0231   BOOST_CHECK(epa.getAxisDirection() == AxisY);
0232   BOOST_CHECK(epa.getAxis().isEquidistant());
0233   BOOST_CHECK(epa.isAutorange());
0234   std::string reString =
0235       "DirectedProtoAxis: 10 bins in AxisY, equidistant within automatic range";
0236   std::string oeString = epa.toString();
0237   BOOST_CHECK_EQUAL(reString, oeString);
0238
0239   // Bound, equidistant axis - directed at z
0240   Acts::DirectedProtoAxis epab(AxisZ, Bound, 0.0, 1.0, 10);
0241   BOOST_CHECK(epab.getAxisDirection() == AxisZ);
0242   BOOST_CHECK(epab.getAxis().isEquidistant());
0243   BOOST_CHECK(!epab.isAutorange());
0244   std::string rString =
0245       "DirectedProtoAxis: 10 bins in AxisZ, equidistant within [0, 1]";
0246   std::string oString = epab.toString();
0247   BOOST_CHECK_EQUAL(rString, oString);
0248 }
0249
0250 BOOST_AUTO_TEST_SUITE_END()
0251
0252 }  // namespace ActsTests