Core/Utilities/BinUtilityTests.cpp

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/Utilities/BinUtility.hpp"
0013 #include "Acts/Utilities/BinningType.hpp"
0014
0015 #include <array>
0016 #include <cmath>
0017 #include <cstddef>
0018 #include <utility>
0019 #include <vector>
0020
0021 namespace Acts::Test {
0022
0023 // OPEN - equidistant binning tests
0024 BOOST_AUTO_TEST_CASE(BinUtility_equidistant_binning) {
0025   Vector3 xyzPosition(1.5, 2.5, 3.5);
0026   Vector3 edgePosition(0.5, 0.5, 0.5);
0027
0028   // | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
0029   BinUtility xUtil_eq(10, 0., 10., open, binX);
0030   BinUtility yUtil_eq(10, 0., 10., open, binY);
0031   BinUtility zUtil_eq(10, 0., 10., open, binZ);
0032   BOOST_CHECK_EQUAL(xUtil_eq.bins(), (std::size_t)10);
0033   // make it 2-dim
0034   BinUtility xyUtil_eq(10, 0., 10., open, binX);
0035   xyUtil_eq += yUtil_eq;
0036   BOOST_CHECK_EQUAL(xyUtil_eq.bins(), 100u);
0037   // make it 3-dim
0038   BinUtility xyzUtil_eq(xyUtil_eq);
0039   xyzUtil_eq += zUtil_eq;
0040   BOOST_CHECK_EQUAL(xyzUtil_eq.bins(), 1000u);
0041   // check the dimensions
0042   BOOST_CHECK_EQUAL(xUtil_eq.dimensions(), 1u);
0043   BOOST_CHECK_EQUAL(xyUtil_eq.dimensions(), 2u);
0044   BOOST_CHECK_EQUAL(xyzUtil_eq.dimensions(), 3u);
0045
0046   // check equality operator
0047   BinUtility xUtil_eq_copy(10, 0., 10., open, binX);
0048   BOOST_CHECK_EQUAL(xUtil_eq_copy, xUtil_eq);
0049   BOOST_CHECK_NE(yUtil_eq, xUtil_eq);
0050
0051   // bin triples and clusters
0052   auto xTriple = xUtil_eq.binTriple(xyzPosition);
0053   auto xyTriple = xyUtil_eq.binTriple(xyzPosition);
0054   auto xyzTriple = xyzUtil_eq.binTriple(xyzPosition);
0055
0056   BOOST_CHECK_EQUAL(xTriple[0], 1u);
0057   BOOST_CHECK_EQUAL(xTriple[1], 0u);
0058   BOOST_CHECK_EQUAL(xTriple[2], 0u);
0059
0060   BOOST_CHECK_EQUAL(xyTriple[0], 1u);
0061   BOOST_CHECK_EQUAL(xyTriple[1], 2u);
0062   BOOST_CHECK_EQUAL(xyTriple[2], 0u);
0063
0064   BOOST_CHECK_EQUAL(xyzTriple[0], 1u);
0065   BOOST_CHECK_EQUAL(xyzTriple[1], 2u);
0066   BOOST_CHECK_EQUAL(xyzTriple[2], 3u);
0067 }
0068
0069 // OPEN - equidistant binning tests
0070 BOOST_AUTO_TEST_CASE(BinUtility_arbitrary_binning) {
0071   std::vector<float> bvalues = {-5., 0., 1., 1.1, 8.};
0072   BinUtility xUtil(bvalues, Acts::open, Acts::binX);
0073
0074   // Underflow
0075   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(-6., 0., 0.)), 0u);
0076   // Bin 0
0077   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(-4., 0., 0.)), 0u);
0078   // Bin 1
0079   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(0.5, 0., 0.)), 1u);
0080   // Bin 2
0081   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(1.05, 0., 0.)), 2u);
0082   // Bin 3
0083   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(4., 0., 0.)), 3u);
0084   // Overflow
0085   BOOST_CHECK_EQUAL(xUtil.bin(Vector3(9., 0., 0.)), 3u);
0086 }
0087
0088 // OPEN - local to global transform test
0089 BOOST_AUTO_TEST_CASE(BinUtility_transform) {
0090   Transform3 transform_LtoG = Transform3::Identity();
0091   transform_LtoG = transform_LtoG * Translation3(0., 0., -50);
0092   transform_LtoG = transform_LtoG * AngleAxis3(M_PI / 4, Vector3(0, 0, 1));
0093
0094   Transform3 transform_GtoL = transform_LtoG.inverse();
0095
0096   BinUtility rUtil(10, 0., 100., open, binR);
0097   BinUtility phiUtil(10, -M_PI, M_PI, closed, binPhi);
0098   BinUtility zUtil(10, -100., 100., open, binZ);
0099
0100   BinUtility noTranform;
0101   noTranform += rUtil;
0102   noTranform += phiUtil;
0103   noTranform += zUtil;
0104
0105   BinUtility withTranform(transform_LtoG);
0106   withTranform += rUtil;
0107   withTranform += phiUtil;
0108   withTranform += zUtil;
0109
0110   Vector3 pos1(0, 0, 0);
0111   Vector3 pos2(60, 0, 0);
0112   Vector3 pos3(34, M_PI / 2, 0);
0113   Vector3 pos4(0, 0, -80);
0114   Vector3 pos5(80, -M_PI / 4, 50);
0115
0116   for (int i = 0; i < 3; i++) {
0117     BOOST_CHECK_EQUAL(withTranform.bin(pos1, i),
0118                       noTranform.bin(transform_GtoL * pos1, i));
0119     BOOST_CHECK_EQUAL(withTranform.bin(pos2, i),
0120                       noTranform.bin(transform_GtoL * pos2, i));
0121     BOOST_CHECK_EQUAL(withTranform.bin(pos3, i),
0122                       noTranform.bin(transform_GtoL * pos3, i));
0123     BOOST_CHECK_EQUAL(withTranform.bin(pos4, i),
0124                       noTranform.bin(transform_GtoL * pos4, i));
0125     BOOST_CHECK_EQUAL(withTranform.bin(pos5, i),
0126                       noTranform.bin(transform_GtoL * pos5, i));
0127   }
0128 }
0129
0130 }  // namespace Acts::Test