tests/cpu/test_grid2.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/primitives.hpp"
0010 #include "traccc/seeding/grids/axis.hpp"
0011 #include "traccc/seeding/grids/grid2.hpp"
0012 #include "traccc/seeding/grids/populator.hpp"
0013 #include "traccc/seeding/grids/serializer2.hpp"
0014
0015 // Vecmem include(s)
0016 #include <vecmem/memory/host_memory_resource.hpp>
0017
0018 // GTest include(s)
0019 #include <gtest/gtest.h>
0020
0021 // System include(s)
0022 #include <limits>
0023
0024 using namespace traccc;
0025
0026 GTEST_TEST(traccc_grid2, grid2_replace_populator) {
0027   vecmem::host_memory_resource host_mr;
0028
0029   serializer2 serializer;
0030
0031   using grid2r = grid2<replace_populator, axis2::regular, axis2::regular,
0032                        decltype(serializer)>;
0033   typename grid2r::axis_p0_type xaxis{10u, -5.f, 5.f, host_mr};
0034   typename grid2r::axis_p1_type yaxis{10u, -5.f, 5.f, host_mr};
0035
0036   grid2r g2(std::move(xaxis), std::move(yaxis), host_mr);
0037
0038   // Test the initialization
0039   point2 p = {-4.5f, -4.5f};
0040   for (unsigned int ib0 = 0u; ib0 < 10u; ++ib0) {
0041     for (unsigned int ib1 = 0u; ib1 < 10u; ++ib1) {
0042       p = {-4.5f + static_cast<scalar>(ib0), -4.5f + static_cast<scalar>(ib1)};
0043       EXPECT_EQ(g2.bin(p), std::numeric_limits<unsigned int>::max());
0044     }
0045   }
0046
0047   p = {-4.5f, -4.5f};
0048   // Fill and read
0049   g2.populate(p, 3u);
0050   EXPECT_EQ(g2.bin(p), 3u);
0051
0052   // Fill and read two times, fill first 0-99, then 100-199
0053   for (unsigned int il = 0u; il < 2u; ++il) {
0054     unsigned int counter = il * 100u;
0055     for (unsigned int ib0 = 0u; ib0 < 10u; ++ib0) {
0056       for (unsigned int ib1 = 0; ib1 < 10u; ++ib1) {
0057         p = {-4.5f + static_cast<scalar>(ib0),
0058              -4.5f + static_cast<scalar>(ib1)};
0059         g2.populate(p, counter + 0u);
0060         EXPECT_EQ(g2.bin(p), counter++);
0061       }
0062     }
0063   }
0064
0065   // A zone test w/o neighbour hood
0066   p = {-4.5f, -4.5f};
0067   auto test = g2.zone(p);
0068   vecmem::vector<unsigned int> expect = {100u};
0069   EXPECT_EQ(test, expect);
0070
0071   // A zone test with neighbour hood
0072   p = {0.5f, 0.5f};
0073
0074   std::array<unsigned int, 2> zone11 = {1u, 1u};
0075   std::array<unsigned int, 2> zone22 = {2u, 2u};
0076
0077   test = g2.zone(p, {zone11, zone22}, true);
0078   expect = {143u, 144u, 145u, 146u, 147u, 153u, 154u, 155u,
0079             156u, 157u, 163u, 164u, 165u, 166u, 167u};
0080   EXPECT_EQ(test, expect);
0081
0082   using grid2cc = grid2<replace_populator, axis2::circular, axis2::regular,
0083                         decltype(serializer)>;
0084
0085   typename grid2cc::axis_p0_type circular{4u, -2.f, 2.f, host_mr};
0086   typename grid2cc::axis_p1_type closed{5u, 0.f, 5.f, host_mr};
0087
0088   grid2cc g2cc(std::move(circular), std::move(closed), host_mr);
0089   unsigned int counter = 0u;
0090   for (unsigned icl = 0u; icl < 5u; ++icl) {
0091     for (unsigned ici = 0u; ici < 4u; ++ici) {
0092       p = {-1.5f + static_cast<scalar>(ici), 0.5f + static_cast<scalar>(icl)};
0093       g2cc.populate(p, counter++);
0094     }
0095   }
0096
0097   // A zone test for circular testing
0098   p = {1.5f, 2.5f};
0099   test = g2cc.zone(p, {zone11, zone11}, true);
0100   expect = {4u, 6u, 7u, 8u, 10u, 11u, 12u, 14u, 15u};
0101   EXPECT_EQ(test, expect);
0102 }
0103
0104 GTEST_TEST(traccc_grid2, grid2_complete_populator) {
0105   constexpr auto invalid_index{std::numeric_limits<unsigned int>::max()};
0106
0107   vecmem::host_memory_resource host_mr;
0108
0109   serializer2 serializer;
0110
0111   using grid2r =
0112       grid2<complete_populator, axis2::regular, axis2::regular,
0113             decltype(serializer), vecmem::vector, vecmem::jagged_vector,
0114             std::array, detray::tuple, unsigned int, false, 3>;
0115
0116   typename grid2r::axis_p0_type xaxis{2u, -1.f, 1.f, host_mr};
0117   typename grid2r::axis_p1_type yaxis{2u, -1.f, 1.f, host_mr};
0118
0119   grid2r g2(std::move(xaxis), std::move(yaxis), host_mr);
0120
0121   // Test the initialization
0122   point2 p = {-0.5f, -0.5f};
0123   grid2r::populator_type::store_value invalid = {invalid_index, invalid_index,
0124                                                  invalid_index};
0125   for (unsigned int ib0 = 0u; ib0 < 2u; ++ib0) {
0126     for (unsigned int ib1 = 0u; ib1 < 2u; ++ib1) {
0127       p = {-0.5f + static_cast<scalar>(ib0), -0.5f + static_cast<scalar>(ib1)};
0128       EXPECT_EQ(g2.bin(p), invalid);
0129     }
0130   }
0131
0132   // Fill and read
0133   p = {-0.5f, -0.5f};
0134   g2.populate(p, 4u);
0135
0136   grid2r::populator_type::store_value expected = {4u, invalid_index,
0137                                                   invalid_index};
0138   auto test = g2.bin(p);
0139   EXPECT_EQ(test, expected);
0140
0141   auto zone_test = g2.zone(p);
0142   vecmem::vector<unsigned int> zone_expected = {4u};
0143   EXPECT_EQ(zone_test, zone_expected);
0144
0145   g2.populate(p, 2u);
0146   expected = {4u, 2u, invalid_index};
0147   test = g2.bin(p);
0148   EXPECT_EQ(test, expected);
0149
0150   g2.populate(p, 7u);
0151   expected = {4u, 2u, 7u};
0152   test = g2.bin(p);
0153   EXPECT_EQ(test, expected);
0154
0155   // Bin is completed, new entry is ignored
0156   g2.populate(p, 16u);
0157   test = g2.bin(p);
0158   EXPECT_EQ(test, expected);
0159
0160   std::array<unsigned int, 2> zone00 = {0u, 0u};
0161   std::array<unsigned int, 2> zone11 = {1u, 1u};
0162
0163   // Zone test of a complete bin
0164   zone_test = g2.zone(p, {zone00, zone00});
0165   zone_expected = {4u, 2u, 7u};
0166   EXPECT_EQ(zone_test, zone_expected);
0167
0168   // Fill some other bins
0169   p = {0.5f, -0.5f};
0170   g2.populate(p, 16u);
0171
0172   p = {0.5f, 0.5f};
0173   g2.populate(p, 17u);
0174   g2.populate(p, 18u);
0175
0176   zone_test = g2.zone(p, {zone11, zone11});
0177   zone_expected = {4u, 2u, 7u, 16u, 17u, 18u};
0178   EXPECT_EQ(zone_test, zone_expected);
0179 }
0180
0181 GTEST_TEST(traccc_grid2, grid2_attach_populator) {
0182   vecmem::host_memory_resource host_mr;
0183
0184   serializer2 serializer;
0185
0186   using grid2r = grid2<attach_populator, axis2::regular, axis2::regular,
0187                        decltype(serializer)>;
0188   typename grid2r::axis_p0_type xaxis{2u, -1.f, 1.f, host_mr};
0189   typename grid2r::axis_p1_type yaxis{2u, -1.f, 1.f, host_mr};
0190
0191   grid2r g2(std::move(xaxis), std::move(yaxis), host_mr);
0192
0193   // Test the initialization
0194   point2 p = {-0.5f, -0.5f};
0195   grid2r::populator_type::store_value invalid = {};
0196   for (unsigned int ib0 = 0u; ib0 < 2u; ++ib0) {
0197     for (unsigned int ib1 = 0u; ib1 < 2u; ++ib1) {
0198       p = {-0.5f + static_cast<scalar>(ib0), -0.5f + static_cast<scalar>(ib1)};
0199       EXPECT_EQ(g2.bin(p), invalid);
0200     }
0201   }
0202
0203   p = {-0.5f, -0.5f};
0204   g2.populate(p, 4u);
0205
0206   grid2r::populator_type::store_value expected = {4u};
0207   auto test = g2.bin(p);
0208   EXPECT_EQ(test, expected);
0209
0210   auto zone_test = g2.zone(p);
0211   vecmem::vector<unsigned int> zone_expected = {4u};
0212   EXPECT_EQ(zone_test, zone_expected);
0213
0214   p = {-0.5f, 0.5f};
0215   g2.populate(p, 9u);
0216
0217   p = {0.5f, -0.5f};
0218   g2.populate(p, 1u);
0219
0220   p = {0.5f, 0.5f};
0221   g2.populate(p, 7u);
0222
0223   expected = {7u};
0224   test = g2.bin(p);
0225   EXPECT_EQ(test, expected);
0226
0227   std::array<unsigned int, 2> zone11 = {1u, 1u};
0228
0229   zone_test = g2.zone(p, {zone11, zone11}, true);
0230   zone_expected = {1u, 4u, 7u, 9u};
0231   EXPECT_EQ(zone_test, zone_expected);
0232 }
0233
0234 GTEST_TEST(traccc_grid2, grid2_shift) {
0235   vecmem::host_memory_resource host_mr;
0236
0237   serializer2 serializer;
0238
0239   using grid2r = grid2<replace_populator, axis2::regular, axis2::regular,
0240                        decltype(serializer)>;
0241
0242   typename grid2r::axis_p0_type xaxis{10u, -5.f, 5.f, host_mr};
0243   typename grid2r::axis_p1_type yaxis{10u, -5.f, 5.f, host_mr};
0244
0245   grid2r g2(std::move(xaxis), std::move(yaxis), host_mr, 0);
0246
0247   // Test the initialization
0248   point2 p = {-4.5f, -4.5f};
0249   EXPECT_EQ(g2.bin(p), 0u);
0250
0251   g2.shift(8u);
0252   EXPECT_EQ(g2.bin(p), 8u);
0253 }
0254
0255 GTEST_TEST(traccc_grid2, grid2_irregular_replace) {
0256   vecmem::host_memory_resource host_mr;
0257
0258   replace_populator<> replacer;
0259   serializer2 serializer;
0260
0261   using grid2ir = grid2<replace_populator, axis2::irregular, axis2::irregular,
0262                         decltype(serializer)>;
0263
0264   typename grid2ir::axis_p0_type xaxis{
0265       {-3.f, -2.f, 1.f, 0.5f, 0.7f, 0.71f, 4.f, 1000.f}, host_mr};
0266   typename grid2ir::axis_p1_type yaxis{{0.1f, 0.8f, 0.9f, 10.f, 12.f, 15.f},
0267                                        host_mr};
0268
0269   grid2ir g2(std::move(xaxis), std::move(yaxis), host_mr);
0270
0271   point2 p = {-0.5f, 0.5f};
0272   g2.populate(p, 4u);
0273   EXPECT_EQ(g2.bin(p), 4u);
0274 }