Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-06 08:11:32 

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