Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-16 09:25:16 

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