tests/cpu/test_axis.cpp

0001 /** TRACCC library, part of the ACTS project (R&D line)
0002  *
0003  * (c) 2020-2026 CERN for the benefit of the ACTS project
0004  *
0005  * Mozilla Public License Version 2.0
0006  */
0007
0008 // Project include(s)
0009 #include "traccc/definitions/common.hpp"
0010 #include "traccc/definitions/primitives.hpp"
0011 #include "traccc/seeding/grids/axis.hpp"
0012
0013 // Vecmem include(s)
0014 #include <vecmem/memory/host_memory_resource.hpp>
0015
0016 // GTest include(s)
0017 #include <gtest/gtest.h>
0018
0019 // System include(s)
0020 #include <limits>
0021
0022 // detray core
0023
0024 using namespace traccc;
0025
0026 GTEST_TEST(traccc_grid2, regular_closed_axis) {
0027   vecmem::host_memory_resource resource;
0028
0029   axis2::regular<> ten_bins{10u, -3.f, 7.f, resource};
0030   // N bins
0031   EXPECT_EQ(ten_bins.bins(), 10u);
0032   // Axis bin access
0033   EXPECT_EQ(ten_bins.bin(-4.f), 0u);
0034   EXPECT_EQ(ten_bins.bin(2.5f), 5u);
0035   EXPECT_EQ(ten_bins.bin(8.f), 9u);
0036
0037   // Axis range access - binned (symmetric & asymmetric)
0038   std::array<unsigned int, 2> zone00 = {0u, 0u};
0039   std::array<unsigned int, 2> zone01 = {0u, 1u};
0040   std::array<unsigned int, 2> zone11 = {1u, 1u};
0041   std::array<unsigned int, 2> zone44 = {4u, 4u};
0042   std::array<unsigned int, 2> zone55 = {5u, 5u};
0043
0044   std::array<unsigned int, 2> expected_range = {5u, 5u};
0045   EXPECT_EQ(ten_bins.range(2.5f, zone00), expected_range);
0046   expected_range = {4u, 6u};
0047   EXPECT_EQ(ten_bins.range(2.5f, zone11), expected_range);
0048   expected_range = {5u, 6u};
0049   EXPECT_EQ(ten_bins.range(2.5f, zone01), expected_range);
0050   expected_range = {0u, 8u};
0051   EXPECT_EQ(ten_bins.range(1.5f, zone44), expected_range);
0052   expected_range = {3u, 9u};
0053   EXPECT_EQ(ten_bins.range(5.5f, zone55), expected_range);
0054
0055   // Axis sequence access - binned (symmetric & asymmetric)
0056   vecmem::vector<unsigned int> expected_zone = {5u};
0057   EXPECT_EQ(ten_bins.zone(2.5f, zone00), expected_zone);
0058   expected_zone = {5u, 6u};
0059   EXPECT_EQ(ten_bins.zone(2.5f, zone01), expected_zone);
0060   expected_zone = {4u, 5u, 6u};
0061   EXPECT_EQ(ten_bins.zone(2.5f, zone11), expected_zone);
0062   expected_zone = {0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u};
0063   EXPECT_EQ(ten_bins.zone(1.5f, zone44), expected_zone);
0064
0065   // Axis range access - scalar (symmteric & asymmetric)
0066   std::array<scalar, 2> szone00 = {0.f, 0.f};
0067   std::array<scalar, 2> sepsilon = {0.01f, 0.01f};
0068   std::array<scalar, 2> szone11 = {1.f, 1.f};
0069   std::array<scalar, 2> szoneAll = {10.f, 10.f};
0070
0071   expected_range = {5u, 5u};
0072   EXPECT_EQ(ten_bins.range(2.5f, szone00), expected_range);
0073   EXPECT_EQ(ten_bins.range(2.5f, sepsilon), expected_range);
0074   expected_range = {4u, 6u};
0075   EXPECT_EQ(ten_bins.range(2.5f, szone11), expected_range);
0076   expected_range = {0u, 9u};
0077   EXPECT_EQ(ten_bins.range(2.5f, szoneAll), expected_range);
0078
0079   // Axis sequence acces - scalar (symmteric & asymmetric)
0080   expected_zone = {5u};
0081   EXPECT_EQ(ten_bins.zone(2.5f, szone00), expected_zone);
0082   EXPECT_EQ(ten_bins.zone(2.5f, sepsilon), expected_zone);
0083   expected_zone = {4u, 5u, 6u};
0084   EXPECT_EQ(ten_bins.zone(2.5f, szone11), expected_zone);
0085   expected_zone = {0u, 1u, 2u, 3u, 4u, 5u, 6u, 7u, 8u, 9u};
0086   EXPECT_EQ(ten_bins.zone(2.5f, szoneAll), expected_zone);
0087 }
0088
0089 GTEST_TEST(traccc_grid2, regular_circular_axis) {
0090   vecmem::host_memory_resource resource;
0091
0092   constexpr scalar epsilon{10.f * std::numeric_limits<scalar>::epsilon()};
0093
0094   // Let's say 36 modules, but with 4 directly at 0, pi/2, pi, -pi2
0095   scalar half_module{constant<scalar>::pi / 72.f};
0096   scalar phi_min = -constant<scalar>::pi + half_module;
0097   scalar phi_max = constant<scalar>::pi - half_module;
0098   axis2::circular<> full_pi = {36u, phi_min, phi_max, resource};
0099   // N bins
0100   EXPECT_EQ(full_pi.bins(), 36u);
0101   // Axis bin access
0102   EXPECT_EQ(full_pi.bin(constant<scalar>::pi - epsilon), 0u);
0103   EXPECT_EQ(full_pi.bin(constant<scalar>::pi + epsilon), 0u);
0104   EXPECT_EQ(full_pi.bin(0u), 18u);
0105   // Remap test
0106   EXPECT_EQ(full_pi.remap(4, -1), 3u);
0107   EXPECT_EQ(full_pi.remap(4, 1), 5u);
0108   EXPECT_EQ(full_pi.remap(0, -1), 35u);
0109   EXPECT_EQ(full_pi.remap(0, -2), 34u);
0110   EXPECT_EQ(full_pi.remap(1, -1), 0u);
0111   EXPECT_EQ(full_pi.remap(35, 1), 0u);
0112
0113   // Axis range access - binned (symmetric & asymmetric)
0114   std::array<unsigned int, 2> zone00 = {0u, 0u};
0115   std::array<unsigned int, 2> zone01 = {0u, 1u};
0116   std::array<unsigned int, 2> zone11 = {1u, 1u};
0117   std::array<unsigned int, 2> zone22 = {2u, 2u};
0118
0119   std::array<unsigned int, 2> expected_range = {0u, 0u};
0120   EXPECT_EQ(full_pi.range(constant<scalar>::pi + epsilon, zone00),
0121             expected_range);
0122   expected_range = {0u, 1u};
0123   EXPECT_EQ(full_pi.range(constant<scalar>::pi + epsilon, zone01),
0124             expected_range);
0125   expected_range = {35u, 1u};
0126   EXPECT_EQ(full_pi.range(constant<scalar>::pi + epsilon, zone11),
0127             expected_range);
0128   expected_range = {34u, 2u};
0129   EXPECT_EQ(full_pi.range(constant<scalar>::pi + epsilon, zone22),
0130             expected_range);
0131
0132   // Zone test - binned
0133   vecmem::vector<unsigned int> expected_zone = {34u, 35u, 0u, 1u, 2u};
0134   EXPECT_EQ(full_pi.zone(constant<scalar>::pi + epsilon, zone22),
0135             expected_zone);
0136
0137   // Axis range access - scalar (symmetric & asymmteric)
0138   std::array<scalar, 2> szone00 = {0.f, 0.f};
0139   std::array<scalar, 2> szoneEpsilon = {0.5f * epsilon, 0.5f * epsilon};
0140   scalar bin_step =
0141       (full_pi.max - full_pi.min) / static_cast<scalar>(full_pi.bins());
0142   std::array<scalar, 2> szone22 = {2.f * bin_step, 2.f * bin_step};
0143
0144   expected_range = {0u, 0u};
0145   EXPECT_EQ(full_pi.range(constant<scalar>::pi + epsilon, szone00),
0146             expected_range);
0147   EXPECT_EQ(full_pi.range(constant<scalar>::pi + epsilon, szoneEpsilon),
0148             expected_range);
0149
0150   expected_range = {34u, 2u};
0151   EXPECT_EQ(full_pi.range(constant<scalar>::pi + epsilon, szone22),
0152             expected_range);
0153
0154   expected_zone = {34u, 35u, 0u, 1u, 2u};
0155   EXPECT_EQ(full_pi.zone(constant<scalar>::pi + epsilon, szone22),
0156             expected_zone);
0157 }
0158
0159 GTEST_TEST(traccc_grid2, irregular_closed_axis) {
0160   vecmem::host_memory_resource resource;
0161
0162   axis2::irregular<> nonreg({-3.f, 1.f, 2.f, 4.f, 8.f, 12.f}, resource);
0163
0164   // Axis bin access
0165   //
0166   // N bins
0167   EXPECT_EQ(nonreg.bins(), 5u);
0168   // Bin tests
0169   EXPECT_EQ(nonreg.bin(-2), 0u);
0170   EXPECT_EQ(nonreg.bin(10), 4u);
0171   // Underflow test
0172   EXPECT_EQ(nonreg.bin(-4), 0u);
0173   // Overflow test
0174   EXPECT_EQ(nonreg.bin(14), 4u);
0175
0176   // Axis range access - binned  (symmetric & asymmetric)
0177   std::array<unsigned int, 2> zone01 = {0u, 1u};
0178   std::array<unsigned int, 2> zone11 = {1u, 1u};
0179   std::array<unsigned int, 2> zone22 = {2u, 2u};
0180
0181   std::array<unsigned int, 2> expected_range = {1u, 3u};
0182   EXPECT_EQ(nonreg.range(3.f, zone11), expected_range);
0183
0184   expected_range = {2u, 3u};
0185   EXPECT_EQ(nonreg.range(3.f, zone01), expected_range);
0186
0187   std::array<unsigned int, 2> expected_range_truncated_low = {0u, 1u};
0188   EXPECT_EQ(nonreg.range(0.f, zone11), expected_range_truncated_low);
0189
0190   std::array<unsigned int, 2> expected_range_truncated_high = {2u, 4u};
0191   EXPECT_EQ(nonreg.range(10.f, zone22), expected_range_truncated_high);
0192
0193   // Axis sequence access - binned
0194   vecmem::vector<unsigned int> expected_zone = {1u, 2u, 3u};
0195   EXPECT_EQ(nonreg.zone(3.f, zone11), expected_zone);
0196
0197   vecmem::vector<unsigned int> expected_zone_truncated_low = {0u, 1u};
0198   EXPECT_EQ(nonreg.zone(0.f, zone11), expected_zone_truncated_low);
0199
0200   vecmem::vector<unsigned int> expected_zone_truncated_high = {2u, 3u, 4u};
0201   EXPECT_EQ(nonreg.zone(10.f, zone22), expected_zone_truncated_high);
0202
0203   // Axis range access - scalar
0204   std::array<scalar, 2> szone00 = {0.f, 0.f};
0205   std::array<scalar, 2> szone10 = {1.5f, 0.2f};
0206   expected_range = {2u, 2u};
0207   EXPECT_EQ(nonreg.range(3.f, szone00), expected_range);
0208
0209   expected_range = {1u, 2u};
0210   EXPECT_EQ(nonreg.range(3.f, szone10), expected_range);
0211
0212   // Axis sequence access - scalar
0213   expected_zone = {2u};
0214   EXPECT_EQ(nonreg.zone(3.f, szone00), expected_zone);
0215
0216   expected_zone = {1u, 2u};
0217   EXPECT_EQ(nonreg.zone(3.f, szone10), expected_zone);
0218 }