Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-07-01 07:54:11 

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

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!