Core/Utilities/BinningDataTests.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/unit_test.hpp>
0010
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Utilities/AxisDefinitions.hpp"
0013 #include "Acts/Utilities/BinningData.hpp"
0014 #include "Acts/Utilities/BinningType.hpp"
0015 #include "Acts/Utilities/IAxis.hpp"
0016 #include "Acts/Utilities/ProtoAxis.hpp"
0017 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0018
0019 #include <cmath>
0020 #include <cstddef>
0021 #include <memory>
0022 #include <numbers>
0023 #include <utility>
0024 #include <vector>
0025
0026 using namespace Acts;
0027
0028 namespace ActsTests {
0029
0030 // the test positions in 3D
0031 Vector3 xyzPosition(0.5, 1.5, 2.5);
0032 Vector3 xyzPositionOutside(30., -30., 200.);
0033 Vector3 phi0Position(0.5, 0., 2.5);
0034 Vector3 phiPihPosition(0., 1.5, 2.5);
0035 Vector3 eta0Position(0.5, 1.5, 0.);
0036 // the test positions in 2D
0037 Vector2 xyPosition(0.5, 1.5);
0038 Vector2 rphizPosition(0.1, 2.5);
0039 Vector2 rphiPosition(3.5, std::numbers::pi / 8.);
0040
0041 // the binnings - equidistant
0042 // x/y/zData
0043 // bin boundaries
0044 // | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0045 BinningData xData_eq(open, AxisDirection::AxisX, 10, 0., 10.);
0046 BinningData yData_eq(open, AxisDirection::AxisY, 10, 0., 10.);
0047 BinningData zData_eq(open, AxisDirection::AxisZ, 10, 0., 10.);
0048 // r/phi/rphiData
0049 // bin boundaries
0050 // | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0051 BinningData rData_eq(open, AxisDirection::AxisR, 10, 0., 10.);
0052 // bin boundaries
0053 // > -PI | -3/5 PI | -1/5 PI | 1/5 PI | 3/5 PI | PI <
0054 BinningData phiData_eq(closed, AxisDirection::AxisPhi, 5, -std::numbers::pi,
0055                        std::numbers::pi);
0056 // BinningData rPhiData_eq(closed, AxisDirection::AxisRPhi, 5,
0057 // -std::numbers::pi, std::numbers::pi); h/etaData bin boundaries | 0 | 2 | 4 |
0058 // 6 | 8 | 10 | BinningData hData_eq(open, AxisDirection::AxisTheta, 5,
0059 // 0., 10.); | -2.5 | -1.5 | -0.5 | 0.5 | 1.5 | 2.5 |
0060 BinningData etaData_eq(open, AxisDirection::AxisEta, 5, -2.5, 2.5);
0061
0062 // Fest equality operator
0063 BinningData xData_eq_copy(open, AxisDirection::AxisX, 10, 0., 10.);
0064
0065 // the binnings - arbitrary
0066 std::vector<float> values = {0., 1., 2., 3., 4., 10.};
0067 // bin boundaries
0068 // | 0 | 1 | 2 | 3 | 4 | 10 |
0069 BinningData xData_arb(open, AxisDirection::AxisX, values);
0070 BinningData yData_arb(open, AxisDirection::AxisY, values);
0071 // | -PI |  -2 |  -1 |  1 |  2 |  PI |
0072 std::vector<float> phiValues = {-std::numbers::pi, -2., -1., 1., 2.,
0073                                 std::numbers::pi};
0074 BinningData phiData_arb(closed, AxisDirection::AxisPhi, phiValues);
0075
0076 // the binnings - arbitrary when switching to binary search - for boundary
0077 // sizes >= 50
0078 std::size_t nBins_binary = 59;
0079 double valueMin = 0.;
0080 double phiMin = -std::numbers::pi;
0081 double delta = 0.5;
0082 double phiDelta = 0.1064;
0083
0084 // the binning - substructure
0085 std::vector<float> sstr = {0., 1., 1.5, 2., 3.};
0086 // multiplicative
0087 auto xData_sstr_mult =
0088     std::make_unique<const BinningData>(open, AxisDirection::AxisX, sstr);
0089 // | 0 | 1 | 1.5 | 2 |  3 | 4 | 4.5 | 5 | 6 | 7 | 7.5 | 8 | 9 |
0090 BinningData xData_mult(open, AxisDirection::AxisX, 3, 0., 9.,
0091                        std::move(xData_sstr_mult));
0092 /// additive
0093 // | 0 | 1 | 1.5 | 2 |  3 | 4 | 5 |
0094 std::vector<float> main_sstr = {0., 3., 4., 5.};
0095 auto xData_sstr_add =
0096     std::make_unique<const BinningData>(open, AxisDirection::AxisX, sstr);
0097 BinningData xData_add(open, AxisDirection::AxisX, main_sstr,
0098                       std::move(xData_sstr_add));
0099
0100 // enum AxisDirection { AxisDirection::AxisX, AxisDirection::AxisY,
0101 // AxisDirection::AxisZ, AxisDirection::AxisR, AxisDirection::AxisPhi,
0102 // AxisDirection::AxisRPhi, AxisDirection::AxisTheta, AxisDirection::AxisEta }
0103 //
0104
0105 BOOST_AUTO_TEST_SUITE(UtilitiesSuite)
0106
0107 // test the different binning values
0108 BOOST_AUTO_TEST_CASE(BinningData_AxisDirection) {
0109   // the binnings - arbitrary when switching to binary search - for boundary
0110   // sizes >= 50
0111   std::vector<float> values_binary;
0112   std::vector<float> phiValues_binary;
0113   for (std::size_t i = 0; i <= nBins_binary; i++) {
0114     values_binary.push_back(valueMin + i * delta);
0115     phiValues_binary.push_back(phiMin + i * phiDelta);
0116   }
0117   // bin boundaries when switching to binary search - for boundary sizes >= 50
0118   BinningData xData_arb_binary(open, AxisDirection::AxisX, values_binary);
0119   BinningData phiData_arb_binary(closed, AxisDirection::AxisPhi,
0120                                  phiValues_binary);
0121   /// x/y/zData
0122   /// check the global position requests
0123   // | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0124   BOOST_CHECK_EQUAL(xData_eq.bins(), std::size_t{10});
0125   // | 0 | 1 | 2 | 3 | 4 | 10 |
0126   BOOST_CHECK_EQUAL(xData_arb.bins(), std::size_t{5});
0127   // | 0 | 1 | 1.5 | 2 | 3 | 4 | 4.5 | 5 | 6 | 7 | 7.5 | 8 | 9 |
0128   BOOST_CHECK_EQUAL(xData_mult.bins(), std::size_t{12});
0129   // | 0 | 1 | 1.5 | 2 |  3 | 4 | 5 |
0130   BOOST_CHECK_EQUAL(xData_add.bins(), std::size_t{6});
0131   BOOST_CHECK_EQUAL(xData_arb_binary.bins(), nBins_binary);
0132
0133   BOOST_CHECK(xData_eq_copy == xData_eq_copy);
0134   BOOST_CHECK(!(xData_eq == yData_eq));
0135
0136   /// check the global position requests
0137   BOOST_CHECK_EQUAL(xData_eq.value(xyzPosition), 0.5);
0138   BOOST_CHECK_EQUAL(yData_eq.value(xyzPosition), 1.5);
0139   BOOST_CHECK_EQUAL(zData_eq.value(xyzPosition), 2.5);
0140   BOOST_CHECK_EQUAL(xData_arb.value(xyzPosition), 0.5);
0141   BOOST_CHECK_EQUAL(xData_mult.value(xyzPosition), 0.5);
0142   BOOST_CHECK_EQUAL(xData_add.value(xyzPosition), 0.5);
0143   BOOST_CHECK_EQUAL(xData_arb_binary.value(xyzPosition), 0.5);
0144
0145   /// check the local position requests
0146   BOOST_CHECK_EQUAL(xData_eq.value(xyPosition), 0.5);
0147   BOOST_CHECK_EQUAL(yData_eq.value(xyPosition), 1.5);
0148   BOOST_CHECK_EQUAL(zData_eq.value(rphizPosition), 2.5);
0149   BOOST_CHECK_EQUAL(xData_arb.value(xyPosition), 0.5);
0150   BOOST_CHECK_EQUAL(xData_mult.value(xyPosition), 0.5);
0151   BOOST_CHECK_EQUAL(xData_add.value(xyPosition), 0.5);
0152   BOOST_CHECK_EQUAL(xData_arb_binary.value(xyPosition), 0.5);
0153
0154   // r/phi/rphiData
0155   CHECK_CLOSE_REL(rData_eq.value(xyzPosition), std::hypot(0.5, 1.5), 1e-5);
0156   BOOST_CHECK_EQUAL(rData_eq.value(rphiPosition), 3.5);
0157
0158   CHECK_SMALL(phiData_eq.value(phi0Position), 1e-6 * std::numbers::pi);
0159   CHECK_CLOSE_REL(phiData_eq.value(phiPihPosition), std::numbers::pi / 2.,
0160                   1e-5);
0161
0162   BOOST_CHECK_EQUAL(phiData_eq.bins(), std::size_t{5});
0163   BOOST_CHECK_EQUAL(phiData_arb.bins(), std::size_t{5});
0164   BOOST_CHECK_EQUAL(phiData_arb_binary.bins(), nBins_binary);
0165
0166   // h/etaData
0167   CHECK_SMALL(etaData_eq.value(eta0Position), 1e-5);
0168 }
0169
0170 // test bin values
0171 BOOST_AUTO_TEST_CASE(BinningData_bins) {
0172   // the binnings - arbitrary when switching to binary search - for boundary
0173   // sizes >= 50
0174   std::vector<float> values_binary;
0175   std::vector<float> phiValues_binary;
0176   for (std::size_t i = 0; i <= nBins_binary; i++) {
0177     values_binary.push_back(valueMin + i * delta);
0178     phiValues_binary.push_back(phiMin + i * phiDelta);
0179   }
0180   // bin boundaries when switching to binary search - for boundary sizes >= 50
0181   BinningData xData_arb_binary(open, AxisDirection::AxisX, values_binary);
0182   BinningData phiData_arb_binary(closed, AxisDirection::AxisPhi,
0183                                  phiValues_binary);
0184   /// x/y/zData
0185   /// check the global position requests
0186   // | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0187   BOOST_CHECK_EQUAL(xData_eq.searchGlobal(xyzPosition), std::size_t{0});
0188   BOOST_CHECK_EQUAL(yData_eq.searchGlobal(xyzPosition), std::size_t{1});
0189   BOOST_CHECK_EQUAL(zData_eq.searchGlobal(xyzPosition), std::size_t{2});
0190   // | 0 | 1 | 2 | 3 | 4 | 10 |
0191   BOOST_CHECK_EQUAL(xData_arb.searchGlobal(xyzPosition), std::size_t{0});
0192   BOOST_CHECK_EQUAL(xData_arb.search(6.), std::size_t{4});
0193   BOOST_CHECK_EQUAL(xData_arb_binary.searchGlobal(xyzPosition), std::size_t{0});
0194   BOOST_CHECK_EQUAL(xData_arb_binary.search(50.), (nBins_binary - 1));
0195   // | 0 | 1 | 1.5 | 2 |  3 | 4 | 5 |
0196   BOOST_CHECK_EQUAL(xData_add.searchGlobal(xyzPosition), std::size_t{0});
0197   BOOST_CHECK_EQUAL(xData_add.searchGlobal(xyzPosition), std::size_t{0});
0198   BOOST_CHECK_EQUAL(xData_add.search(0.2), std::size_t{0});
0199   BOOST_CHECK_EQUAL(xData_add.search(1.2), std::size_t{1});
0200   BOOST_CHECK_EQUAL(xData_add.search(1.7), std::size_t{2});
0201   BOOST_CHECK_EQUAL(xData_add.search(2.5), std::size_t{3});
0202   BOOST_CHECK_EQUAL(xData_add.search(3.5), std::size_t{4});
0203   BOOST_CHECK_EQUAL(xData_add.search(4.2), std::size_t{5});
0204   BOOST_CHECK_EQUAL(xData_add.search(7.), std::size_t{5});
0205   // | 0 | 1 | 1.5 | 2 | 3 | 4 | 4.5 | 5 | 6 | 7 | 7.5 | 8 | 9 |
0206   BOOST_CHECK_EQUAL(xData_mult.searchGlobal(xyzPosition), std::size_t{0});
0207   BOOST_CHECK_EQUAL(xData_mult.search(0.2), std::size_t{0});
0208   BOOST_CHECK_EQUAL(xData_mult.search(1.2), std::size_t{1});
0209   BOOST_CHECK_EQUAL(xData_mult.search(1.7), std::size_t{2});
0210   BOOST_CHECK_EQUAL(xData_mult.search(2.5), std::size_t{3});
0211   BOOST_CHECK_EQUAL(xData_mult.search(3.5), std::size_t{4});
0212   BOOST_CHECK_EQUAL(xData_mult.search(4.2), std::size_t{5});
0213   BOOST_CHECK_EQUAL(xData_mult.search(4.7), std::size_t{6});
0214   BOOST_CHECK_EQUAL(xData_mult.search(5.7), std::size_t{7});
0215   BOOST_CHECK_EQUAL(xData_mult.search(6.5), std::size_t{8});
0216   BOOST_CHECK_EQUAL(xData_mult.search(7.2), std::size_t{9});
0217   BOOST_CHECK_EQUAL(xData_mult.search(7.7), std::size_t{10});
0218   BOOST_CHECK_EQUAL(xData_mult.search(8.1), std::size_t{11});
0219
0220   /// check the local position requests
0221   BOOST_CHECK_EQUAL(xData_eq.searchLocal(xyPosition), std::size_t{0});
0222   BOOST_CHECK_EQUAL(yData_eq.searchLocal(xyPosition), std::size_t{1});
0223   BOOST_CHECK_EQUAL(zData_eq.searchLocal(rphizPosition), std::size_t{2});
0224   BOOST_CHECK_EQUAL(xData_arb.searchLocal(xyPosition), std::size_t{0});
0225   BOOST_CHECK_EQUAL(xData_arb_binary.searchLocal(xyPosition), std::size_t{0});
0226
0227   // r/phi/rphiData
0228   BOOST_CHECK_EQUAL(rData_eq.searchGlobal(xyzPosition), std::size_t{1});
0229   BOOST_CHECK_EQUAL(rData_eq.searchLocal(rphiPosition), std::size_t{3});
0230   BOOST_CHECK_EQUAL(phiData_eq.searchGlobal(phi0Position), std::size_t{2});
0231   BOOST_CHECK_EQUAL(phiData_eq.searchGlobal(phiPihPosition), std::size_t{3});
0232   BOOST_CHECK_EQUAL(phiData_arb_binary.search(std::numbers::pi),
0233                     std::size_t{0});
0234
0235   // h/etaData
0236   BOOST_CHECK_EQUAL(etaData_eq.searchGlobal(eta0Position), std::size_t{2});
0237 }
0238
0239 // test inside/outside
0240 BOOST_AUTO_TEST_CASE(BinningData_inside_outside) {
0241   // the binnings - arbitrary when switching to binary search - for boundary
0242   // sizes >= 50
0243   std::vector<float> values_binary;
0244   std::vector<float> phiValues_binary;
0245   for (std::size_t i = 0; i <= nBins_binary; i++) {
0246     values_binary.push_back(valueMin + i * delta);
0247     phiValues_binary.push_back(phiMin + i * phiDelta);
0248   }
0249   // bin boundaries when switching to binary search - for boundary sizes >= 50
0250   BinningData xData_arb_binary(open, AxisDirection::AxisX, values_binary);
0251   BinningData phiData_arb_binary(closed, AxisDirection::AxisPhi,
0252                                  phiValues_binary);
0253   // check the global inside
0254   BOOST_CHECK_EQUAL(xData_eq.inside(xyzPosition), true);
0255   BOOST_CHECK_EQUAL(yData_eq.inside(xyzPosition), true);
0256   BOOST_CHECK_EQUAL(zData_eq.inside(xyzPosition), true);
0257   BOOST_CHECK_EQUAL(xData_arb.inside(xyzPosition), true);
0258   BOOST_CHECK_EQUAL(xData_add.inside(xyzPosition), true);
0259   BOOST_CHECK_EQUAL(xData_mult.inside(xyzPosition), true);
0260   BOOST_CHECK_EQUAL(xData_arb_binary.inside(xyzPosition), true);
0261
0262   // check the global outside
0263   BOOST_CHECK_EQUAL(xData_eq.inside(xyzPositionOutside), false);
0264   BOOST_CHECK_EQUAL(yData_eq.inside(xyzPositionOutside), false);
0265   BOOST_CHECK_EQUAL(zData_eq.inside(xyzPositionOutside), false);
0266   BOOST_CHECK_EQUAL(xData_arb.inside(xyzPositionOutside), false);
0267   BOOST_CHECK_EQUAL(xData_add.inside(xyzPositionOutside), false);
0268   BOOST_CHECK_EQUAL(xData_mult.inside(xyzPositionOutside), false);
0269   BOOST_CHECK_EQUAL(xData_arb_binary.inside(xyzPositionOutside), false);
0270
0271   // cthe local inside
0272   BOOST_CHECK_EQUAL(xData_eq.inside(xyPosition), true);
0273   BOOST_CHECK_EQUAL(yData_eq.inside(xyPosition), true);
0274   BOOST_CHECK_EQUAL(zData_eq.inside(rphizPosition), true);
0275
0276   // r/phi/rphiData inside
0277   BOOST_CHECK_EQUAL(phiData_eq.inside(phi0Position), true);
0278   BOOST_CHECK_EQUAL(phiData_eq.inside(phiPihPosition), true);
0279   //// h/etaData
0280   BOOST_CHECK_EQUAL(etaData_eq.inside(eta0Position), true);
0281 }
0282
0283 // test open/close
0284 BOOST_AUTO_TEST_CASE(BinningData_open_close) {
0285   // the binnings - arbitrary when switching to binary search - for boundary
0286   // sizes >= 50
0287   std::vector<float> values_binary;
0288   std::vector<float> phiValues_binary;
0289   for (std::size_t i = 0; i <= nBins_binary; i++) {
0290     values_binary.push_back(valueMin + i * delta);
0291     phiValues_binary.push_back(phiMin + i * phiDelta);
0292   }
0293   // bin boundaries when switching to binary search - for boundary sizes >= 50
0294   BinningData xData_arb_binary(open, AxisDirection::AxisX, values_binary);
0295   BinningData phiData_arb_binary(closed, AxisDirection::AxisPhi,
0296                                  phiValues_binary);
0297   // open values
0298   BOOST_CHECK_EQUAL(xData_eq.searchGlobal(xyzPositionOutside), std::size_t{9});
0299   BOOST_CHECK_EQUAL(yData_eq.searchGlobal(xyzPositionOutside), std::size_t{0});
0300   BOOST_CHECK_EQUAL(zData_eq.searchGlobal(xyzPositionOutside), std::size_t{9});
0301   BOOST_CHECK_EQUAL(xData_arb.searchGlobal(xyzPositionOutside) + 1,
0302                     xData_arb.bins());
0303   BOOST_CHECK_EQUAL(xData_arb_binary.searchGlobal(xyzPositionOutside) + 1,
0304                     xData_arb_binary.bins());
0305   BOOST_CHECK_EQUAL(yData_arb.searchGlobal(xyzPositionOutside), std::size_t{0});
0306
0307   // closed values
0308   BOOST_CHECK_EQUAL(phiData_eq.search(-4.), std::size_t{4});
0309   BOOST_CHECK_EQUAL(phiData_eq.search(4.), std::size_t{0});
0310   BOOST_CHECK_EQUAL(phiData_arb.search(-4.), std::size_t{4});
0311   BOOST_CHECK_EQUAL(phiData_arb.search(4.), std::size_t{0});
0312   BOOST_CHECK_EQUAL(phiData_arb_binary.search(-4.), (nBins_binary - 1));
0313   BOOST_CHECK_EQUAL(phiData_arb_binary.search(4.), std::size_t{0});
0314 }
0315
0316 // test boundaries
0317 BOOST_AUTO_TEST_CASE(BinningData_boundaries) {
0318   // open values
0319   std::vector<float> boundaries = {0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.};
0320   BOOST_CHECK_EQUAL_COLLECTIONS(xData_eq.boundaries().begin(),
0321                                 xData_eq.boundaries().end(), boundaries.begin(),
0322                                 boundaries.end());
0323
0324   const float phiStep = std::numbers::pi * 2. / 5.;
0325   std::vector<float> phiBoundaries_eq;
0326
0327   for (int i = 0; i <= 5; ++i) {
0328     phiBoundaries_eq.push_back(
0329         static_cast<float>(-std::numbers::pi + i * phiStep));
0330   }
0331
0332   CHECK_CLOSE_REL(phiData_eq.boundaries(), phiBoundaries_eq, 1e-5);
0333 }
0334
0335 // test bin center values
0336 // test boundaries
0337 BOOST_AUTO_TEST_CASE(BinningData_bincenter) {
0338   // the binnings - arbitrary when switching to binary search - for boundary
0339   // sizes >= 50
0340   std::vector<float> values_binary;
0341   std::vector<float> phiValues_binary;
0342   for (std::size_t i = 0; i <= nBins_binary; i++) {
0343     values_binary.push_back(valueMin + i * delta);
0344     phiValues_binary.push_back(phiMin + i * phiDelta);
0345   }
0346   // bin boundaries when switching to binary search - for boundary sizes >= 50
0347   BinningData xData_arb_binary(open, AxisDirection::AxisX, values_binary);
0348   BinningData phiData_arb_binary(closed, AxisDirection::AxisPhi,
0349                                  phiValues_binary);
0350   /// check the global position requests
0351   // | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0352   BOOST_CHECK_EQUAL(xData_eq.center(3), 3.5);
0353   // | 0 | 1 | 2 | 3 | 4 | 10 |
0354   BOOST_CHECK_EQUAL(xData_arb.center(4), 7.);
0355   // | 0 | 1 | 1.5 | 2 |  3 | 4 | 5 |
0356   BOOST_CHECK_EQUAL(xData_add.center(0), 0.5);
0357   BOOST_CHECK_EQUAL(xData_add.center(1), 1.25);
0358   BOOST_CHECK_EQUAL(xData_add.center(4), 3.5);
0359   // | 0 | 1 | 1.5 | 2 | 3 | 4 | 4.5 | 5 | 6 | 7 | 7.5 | 8 | 9 |
0360   BOOST_CHECK_EQUAL(xData_mult.center(0), 0.5);
0361   BOOST_CHECK_EQUAL(xData_mult.center(1), 1.25);
0362   BOOST_CHECK_EQUAL(xData_mult.center(4), 3.5);
0363   BOOST_CHECK_EQUAL(xData_mult.center(10), 7.75);
0364   BOOST_CHECK_EQUAL(xData_mult.center(11), 8.5);
0365
0366   BOOST_CHECK_EQUAL(xData_arb_binary.center(0), 0.5 * delta);
0367
0368   // open values
0369   std::vector<float> center = {0.5, 1.5, 2.5, 3.5, 4.5,
0370                                5.5, 6.5, 7.5, 8.5, 9.5};
0371   for (std::size_t ib = 0; ib < center.size(); ++ib) {
0372     BOOST_CHECK_EQUAL(xData_eq.center(ib), center[ib]);
0373   }
0374
0375   // running into rounding errors here
0376   const float phiStep = std::numbers::pi * 2. / 5.;
0377   std::vector<float> phiCenters_eq;
0378
0379   for (int i = 0; i < 5; ++i) {
0380     phiCenters_eq.push_back(
0381         static_cast<float>(-std::numbers::pi + (i + 0.5) * phiStep));
0382   }
0383
0384   for (std::size_t ib = 0; ib < phiCenters_eq.size(); ++ib) {
0385     CHECK_CLOSE_ABS(phiData_eq.center(ib), phiCenters_eq[ib], 1e-3);
0386   }
0387 }
0388
0389 // special test for phi binning
0390 BOOST_AUTO_TEST_CASE(BinningData_phi_modules) {
0391   // n phi modules with phi boundary at -pi/+pi are checked above one module
0392   // expands over -pi/+pi
0393   const float deltaPhi = 0.1;
0394   BinningData phiData_mod(closed, AxisDirection::AxisPhi, 5,
0395                           -std::numbers::pi + deltaPhi,
0396                           std::numbers::pi + deltaPhi);
0397
0398   const float phiStep = std::numbers::pi * 2. / 5.;
0399   std::vector<float> phiBoundaries_mod;
0400
0401   for (int i = 0; i <= 5; ++i) {
0402     phiBoundaries_mod.push_back(
0403         static_cast<float>(-std::numbers::pi + i * phiStep) + deltaPhi);
0404   }
0405
0406   // this is the boundary test
0407   CHECK_CLOSE_REL(phiData_mod.boundaries(), phiBoundaries_mod, 1e-5);
0408
0409   // now test the bin jump 0/maxbin
0410
0411   float firstAngle = (-std::numbers::pi + 1.5 * deltaPhi);
0412   Vector3 firstBin(std::cos(firstAngle), std::sin(firstAngle), 0.);
0413   BOOST_CHECK_EQUAL(phiData_mod.search(firstAngle), std::size_t{0});
0414   BOOST_CHECK_EQUAL(phiData_mod.searchGlobal(firstBin), std::size_t{0});
0415
0416   float firstAngleNeg = (-std::numbers::pi + 0.5 * deltaPhi);
0417   Vector3 lastBinNeg(std::cos(firstAngleNeg), std::sin(firstAngleNeg), 0.);
0418   BOOST_CHECK_EQUAL(phiData_mod.search(firstAngleNeg), std::size_t{4});
0419   BOOST_CHECK_EQUAL(phiData_mod.searchGlobal(lastBinNeg), std::size_t{4});
0420
0421   float lastAnglePos = (std::numbers::pi + 0.5 * deltaPhi);
0422   Vector3 lastBinPos(std::cos(lastAnglePos), std::sin(lastAnglePos), 0.);
0423   BOOST_CHECK_EQUAL(phiData_mod.search(lastAnglePos), std::size_t{4});
0424   BOOST_CHECK_EQUAL(phiData_mod.searchGlobal(lastBinPos), std::size_t{4});
0425
0426   // now test the (remaining) phi scaling
0427   float underscaledAngle = -std::numbers::pi - 0.5 * deltaPhi;
0428   Vector3 underscaledPos(std::cos(underscaledAngle), std::sin(underscaledAngle),
0429                          0.);
0430   BOOST_CHECK_EQUAL(phiData_mod.search(underscaledAngle), std::size_t{4});
0431   BOOST_CHECK_EQUAL(phiData_mod.searchGlobal(underscaledPos), std::size_t{4});
0432 }
0433
0434 // special test for phi binning
0435 BOOST_AUTO_TEST_CASE(BinningData_from_ProtoAxis) {
0436   using enum AxisDirection;
0437   using enum AxisBoundaryType;
0438
0439   // Bound, equidistant axis
0440   DirectedProtoAxis epab(AxisX, Bound, 0.0, 1.0, 10);
0441   BinningData bEpab(epab);
0442
0443   BOOST_CHECK_EQUAL(bEpab.bins(), std::size_t{10});
0444   BOOST_CHECK_EQUAL(bEpab.min, 0.);
0445   BOOST_CHECK_EQUAL(bEpab.max, 1.);
0446   BOOST_CHECK(bEpab.binvalue == AxisX);
0447   BOOST_CHECK(bEpab.option == open);
0448   BOOST_CHECK(bEpab.type == equidistant);
0449
0450   // Bound, equidistant axis, autorange
0451   DirectedProtoAxis epa(AxisY, Bound, 10);
0452   BinningData bEpa(epa);
0453   BOOST_CHECK(bEpa.binvalue == AxisY);
0454   BOOST_CHECK_EQUAL(bEpa.bins(), std::size_t{10});
0455   BOOST_CHECK(bEpa.option == open);
0456   BOOST_CHECK(bEpa.type == equidistant);
0457
0458   // Bound, equidistant axis
0459   DirectedProtoAxis vpab(AxisZ, Bound, {0.0, 1.0, 10});
0460   BinningData bVpab(vpab);
0461   BOOST_CHECK(bVpab.binvalue == AxisZ);
0462   BOOST_CHECK_EQUAL(bVpab.bins(), std::size_t{2});
0463   BOOST_CHECK(bVpab.option == open);
0464   BOOST_CHECK(bVpab.type == arbitrary);
0465 }
0466
0467 BOOST_AUTO_TEST_CASE(BinningData_from_IAxis) {
0468   using enum AxisDirection;
0469   using enum AxisBoundaryType;
0470
0471   // Bound, equidistant axis carrying its direction
0472   auto eAxis = IAxis::createEquidistant(Bound, 0.0, 1.0, 10, AxisX);
0473   BinningData bEqui(*eAxis);
0474
0475   BOOST_CHECK_EQUAL(bEqui.bins(), std::size_t{10});
0476   BOOST_CHECK_EQUAL(bEqui.min, 0.);
0477   BOOST_CHECK_EQUAL(bEqui.max, 1.);
0478   BOOST_CHECK(bEqui.binvalue == AxisX);
0479   BOOST_CHECK(bEqui.option == open);
0480   BOOST_CHECK(bEqui.type == equidistant);
0481
0482   // Bound, variable axis carrying its direction
0483   auto vAxis = IAxis::createVariable(Bound, {0.0, 1.0, 10.}, AxisZ);
0484   BinningData bVar(*vAxis);
0485   BOOST_CHECK(bVar.binvalue == AxisZ);
0486   BOOST_CHECK_EQUAL(bVar.bins(), std::size_t{2});
0487   BOOST_CHECK(bVar.option == open);
0488   BOOST_CHECK(bVar.type == arbitrary);
0489
0490   // An axis without direction is rejected
0491   auto nAxis = IAxis::createEquidistant(Bound, 0.0, 1.0, 10);
0492   BOOST_CHECK_THROW(BinningData{*nAxis}, std::invalid_argument);
0493
0494   // Explicitly directed construction works without an axis direction
0495   BinningData bDir(AxisY, *nAxis);
0496   BOOST_CHECK(bDir.binvalue == AxisY);
0497   BOOST_CHECK_EQUAL(bDir.bins(), std::size_t{10});
0498 }
0499
0500 BOOST_AUTO_TEST_SUITE_END()
0501
0502 }  // namespace ActsTests