Core/Seeding/BinnedGroupTest.cpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2024 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/Seeding/BinnedGroup.hpp"
0012 #include "Acts/Utilities/Grid.hpp"
0013 #include "Acts/Utilities/GridBinFinder.hpp"
0014 #include "Acts/Utilities/GridIterator.hpp"
0015
0016 #include <array>
0017 #include <memory>
0018 #include <vector>
0019
0020 namespace Acts::Test {
0021
0022 BOOST_AUTO_TEST_CASE(binned_group_constructor) {
0023   Acts::detail::EquidistantAxis xAxis(0, 100, 10);
0024   Acts::detail::EquidistantAxis yAxis(0, 100, 10);
0025   Acts::detail::EquidistantAxis zAxis(0, 100, 10);
0026
0027   using grid_1d_t =
0028       Acts::Grid<std::vector<std::size_t>, Acts::detail::EquidistantAxis>;
0029   using grid_2d_t =
0030       Acts::Grid<std::vector<std::size_t>, Acts::detail::EquidistantAxis,
0031                  Acts::detail::EquidistantAxis>;
0032   using grid_3d_t =
0033       Acts::Grid<std::vector<std::size_t>, Acts::detail::EquidistantAxis,
0034                  Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis>;
0035
0036   grid_1d_t grid_1d(std::make_tuple(xAxis));
0037   grid_2d_t grid_2d(std::make_tuple(xAxis, yAxis));
0038   grid_3d_t grid_3d(std::make_tuple(xAxis, yAxis, zAxis));
0039
0040   Acts::GridBinFinder<1ul> binFinder_1d(1);
0041   Acts::GridBinFinder<2ul> binFinder_2d(1, 1);
0042   Acts::GridBinFinder<3ul> binFinder_3d(1, 2, 1);
0043
0044   std::array<std::vector<std::size_t>, 1ul> navigation_1d;
0045   navigation_1d[0ul].resize(10);
0046   std::array<std::vector<std::size_t>, 2ul> navigation_2d;
0047   navigation_2d[1ul].resize(10);
0048
0049   // Costructors
0050   // We provide a proper navigation
0051   Acts::BinnedGroup<grid_1d_t> group_1d(std::move(grid_1d), binFinder_1d,
0052                                         binFinder_1d, std::move(navigation_1d));
0053   // We provide a partial navigation, the constructor will complete it
0054   Acts::BinnedGroup<grid_2d_t> group_2d(std::move(grid_2d), binFinder_2d,
0055                                         binFinder_2d, std::move(navigation_2d));
0056   // We do not provide navigation, the constructor will define it
0057   Acts::BinnedGroup<grid_3d_t> group_3d(std::move(grid_3d), binFinder_3d,
0058                                         binFinder_3d);
0059
0060   // Move Constructor/Assignment
0061   const Acts::BinnedGroup<grid_1d_t> group_1d_moved(std::move(group_1d));
0062   const Acts::BinnedGroup<grid_2d_t> group_2d_moved(std::move(group_2d));
0063   const Acts::BinnedGroup<grid_3d_t> group_3d_moved = std::move(group_3d);
0064
0065   [[maybe_unused]] const grid_1d_t& retrievedGrid = group_1d.grid();
0066 }
0067
0068 BOOST_AUTO_TEST_CASE(binned_group_iterations_1d_emptyGrid) {
0069   using grid_t =
0070       Acts::Grid<std::vector<std::size_t>, Acts::detail::EquidistantAxis>;
0071   using binfinder_t = Acts::GridBinFinder<1ul>;
0072
0073   Acts::detail::EquidistantAxis xAxis(0, 100, 10);
0074   grid_t grid(std::make_tuple(std::move(xAxis)));
0075   binfinder_t binfinder(0);
0076   Acts::BinnedGroup<grid_t> group(std::move(grid), binfinder, binfinder);
0077
0078   Acts::BinnedGroupIterator<grid_t> itrStart = group.begin();
0079   Acts::BinnedGroupIterator<grid_t> itrStop = group.end();
0080
0081   std::size_t nIterations = 0ul;
0082   for (; itrStart != itrStop; ++itrStart, ++nIterations) {
0083     [[maybe_unused]] auto candidates = *itrStart;
0084   }
0085
0086   BOOST_CHECK_EQUAL(nIterations, 0ul);
0087 }
0088
0089 BOOST_AUTO_TEST_CASE(binned_group_iterations_2d_emptyGrid) {
0090   using grid_t =
0091       Acts::Grid<std::vector<std::size_t>, Acts::detail::EquidistantAxis,
0092                  Acts::detail::EquidistantAxis>;
0093   using binfinder_t = Acts::GridBinFinder<2ul>;
0094
0095   Acts::detail::EquidistantAxis xAxis(0, 100, 10);
0096   Acts::detail::EquidistantAxis yAxis(0, 100, 10);
0097   grid_t grid(std::make_tuple(std::move(xAxis), std::move(yAxis)));
0098   binfinder_t binfinder(0, 0);
0099   Acts::BinnedGroup<grid_t> group(std::move(grid), binfinder, binfinder);
0100
0101   Acts::BinnedGroupIterator<grid_t> itrStart = group.begin();
0102   Acts::BinnedGroupIterator<grid_t> itrStop = group.end();
0103
0104   std::size_t nIterations = 0ul;
0105   for (; itrStart != itrStop; ++itrStart, ++nIterations) {
0106     [[maybe_unused]] auto candidates = *itrStart;
0107   }
0108
0109   BOOST_CHECK_EQUAL(nIterations, 0ul);
0110 }
0111
0112 BOOST_AUTO_TEST_CASE(binned_group_iterations_1d_perFilledGrid) {
0113   using grid_t =
0114       Acts::Grid<std::vector<std::size_t>, Acts::detail::EquidistantAxis>;
0115   using binfinder_t = Acts::GridBinFinder<1ul>;
0116
0117   Acts::detail::EquidistantAxis xAxis(0, 100, 10);
0118   grid_t grid(std::make_tuple(xAxis));
0119   /// Add some entries to the grid
0120   grid.at(1ul).push_back(4ul);
0121   grid.at(1ul).push_back(1ul);
0122   grid.at(8ul).push_back(7ul);
0123   grid.at(9ul).push_back(2ul);
0124
0125   binfinder_t botBinfinder(0);
0126   binfinder_t topBinfinder(1);
0127   Acts::BinnedGroup<grid_t> group(std::move(grid), botBinfinder, topBinfinder);
0128
0129   std::size_t nIterations = 0ul;
0130   for (const auto [bottom, middle, top] : group) {
0131     ++nIterations;
0132     BOOST_CHECK_EQUAL(bottom.size(), 1ul);
0133     BOOST_CHECK_EQUAL(top.size(), 3ul);
0134   }
0135
0136   BOOST_CHECK_EQUAL(nIterations, 3ul);
0137 }
0138
0139 BOOST_AUTO_TEST_CASE(binned_group_iterations_2d_perFilledGrid) {
0140   using grid_t =
0141       Acts::Grid<std::vector<std::size_t>, Acts::detail::EquidistantAxis,
0142                  Acts::detail::EquidistantAxis>;
0143   using binfinder_t = Acts::GridBinFinder<2ul>;
0144
0145   Acts::detail::EquidistantAxis xAxis(0, 100, 10);
0146   Acts::detail::EquidistantAxis yAxis(0, 100, 10);
0147   grid_t grid(std::make_tuple(xAxis, yAxis));
0148   /// Add some entries to the grid
0149   grid.atLocalBins({2ul, 4ul}).push_back(4ul);
0150   grid.atLocalBins({4ul, 4ul}).push_back(4ul);
0151
0152   binfinder_t botBinfinder(1, 2);
0153   binfinder_t topBinfinder(1, 1);
0154   Acts::BinnedGroup<grid_t> group(std::move(grid), botBinfinder, topBinfinder);
0155
0156   std::size_t nIterations = 0ul;
0157   for (const auto [bottom, middle, top] : group) {
0158     ++nIterations;
0159     BOOST_CHECK_EQUAL(bottom.size(), 15ul);
0160     BOOST_CHECK_EQUAL(top.size(), 9ul);
0161   }
0162
0163   BOOST_CHECK_EQUAL(nIterations, 2ul);
0164 }
0165
0166 BOOST_AUTO_TEST_CASE(binned_group_fill_2d) {
0167   using value_t = std::size_t;
0168   using phiAxis_t = Acts::detail::Axis<detail::AxisType::Equidistant,
0169                                        detail::AxisBoundaryType::Closed>;
0170   using zAxis_t = detail::Axis<detail::AxisType::Equidistant,
0171                                detail::AxisBoundaryType::Bound>;
0172   using grid_t = Acts::Grid<std::vector<value_t>, phiAxis_t, zAxis_t>;
0173   using binfinder_t = Acts::GridBinFinder<2ul>;
0174
0175   phiAxis_t phiAxis(-M_PI, M_PI, 40);
0176   zAxis_t zAxis(0, 100, 10);
0177
0178   grid_t grid(std::make_tuple(std::move(phiAxis), std::move(zAxis)));
0179   binfinder_t binfinder(1, 1);
0180   Acts::BinnedGroup<grid_t> group(std::move(grid), binfinder, binfinder);
0181
0182   /// Fill the grid already owned by the group filling only one bin at a
0183   /// specific local position
0184   std::array<std::size_t, 2ul> locPosition({4ul, 6ul});
0185   std::size_t globPos = group.grid().globalBinFromLocalBins(locPosition);
0186
0187   grid_t& storedGrid = group.grid();
0188   for (std::size_t i(0ul); i < 30ul; ++i) {
0189     storedGrid.at(globPos).push_back(1ul);
0190   }
0191
0192   std::size_t nIterations = 0ul;
0193   for (const auto [bottom, middle, top] : group) {
0194     ++nIterations;
0195     const auto& coll = group.grid().at(middle);
0196     BOOST_CHECK_EQUAL(coll.size(), 30ul);
0197   }
0198
0199   BOOST_CHECK_EQUAL(nIterations, 1ul);
0200 }
0201
0202 BOOST_AUTO_TEST_CASE(binned_group_fill_3d) {
0203   using value_t = std::size_t;
0204   using phiAxis_t = Acts::detail::Axis<detail::AxisType::Equidistant,
0205                                        detail::AxisBoundaryType::Closed>;
0206   using zAxis_t = detail::Axis<detail::AxisType::Equidistant,
0207                                detail::AxisBoundaryType::Bound>;
0208   using rAxis_t = detail::Axis<detail::AxisType::Equidistant,
0209                                detail::AxisBoundaryType::Bound>;
0210   using grid_t = Acts::Grid<std::vector<value_t>, phiAxis_t, zAxis_t, rAxis_t>;
0211   using binfinder_t = Acts::GridBinFinder<3ul>;
0212
0213   phiAxis_t phiAxis(-M_PI, M_PI, 40);
0214   zAxis_t zAxis(0, 100, 10);
0215   rAxis_t rAxis(0, 11000, 1);
0216
0217   grid_t grid(
0218       std::make_tuple(std::move(phiAxis), std::move(zAxis), std::move(rAxis)));
0219   binfinder_t binfinder(1, 1, 0);
0220   Acts::BinnedGroup<grid_t> group(std::move(grid), binfinder, binfinder);
0221
0222   /// Fill the grid already owned by the group filling only one bin at a
0223   /// specific local position
0224   std::array<std::size_t, grid_t::DIM> locPosition({4ul, 6ul, 1ul});
0225   std::size_t globPos = group.grid().globalBinFromLocalBins(locPosition);
0226
0227   grid_t& storedGrid = group.grid();
0228   for (std::size_t i(0ul); i < 30ul; ++i) {
0229     storedGrid.at(globPos).push_back(1ul);
0230   }
0231
0232   std::size_t nIterations = 0ul;
0233   for (const auto [bottom, middle, top] : group) {
0234     ++nIterations;
0235     const auto& coll = group.grid().at(middle);
0236     BOOST_CHECK_EQUAL(coll.size(), 30ul);
0237   }
0238
0239   BOOST_CHECK_EQUAL(nIterations, 1ul);
0240 }
0241
0242 }  // namespace Acts::Test