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