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