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