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