Core/Utilities/GridBinFinderTests.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/Utilities/Grid.hpp"
0012 #include "Acts/Utilities/GridBinFinder.hpp"
0013 #include "Acts/Utilities/GridIterator.hpp"
0014
0015 #include <array>
0016 #include <utility>
0017 #include <vector>
0018
0019 namespace Acts::Test {
0020
0021 BOOST_AUTO_TEST_CASE(grid_binfinder_boundTypes) {
0022   const std::size_t nBins = 10ul;
0023   Acts::GridBinFinder<1ul> binFinder(1);
0024
0025   // take a look at the boundaries of the axes
0026   std::array<std::size_t, 1ul> lowerBound({1ul});
0027   std::array<std::size_t, 1ul> upperBound({10ul});
0028
0029   // For Closed Boundary: out-of-bounds lookups wrap-around to the other side of
0030   // the axis.
0031   Acts::detail::Axis<Acts::detail::AxisType::Equidistant,
0032                      Acts::detail::AxisBoundaryType::Closed>
0033       xAxisClosed(0, 100, nBins);
0034   Acts::Grid<double, decltype(xAxisClosed)> gridClosed(
0035       std::make_tuple(std::move(xAxisClosed)));
0036
0037   auto lowerClosedNeighbours = binFinder.findBins(lowerBound, gridClosed);
0038   BOOST_CHECK_EQUAL(lowerClosedNeighbours.size(), 3ul);
0039   BOOST_CHECK_EQUAL(lowerClosedNeighbours[0ul], 10ul);
0040   BOOST_CHECK_EQUAL(lowerClosedNeighbours[1ul], 1ul);
0041   BOOST_CHECK_EQUAL(lowerClosedNeighbours[2ul], 2ul);
0042
0043   auto upperClosedNeighbours = binFinder.findBins(upperBound, gridClosed);
0044   BOOST_CHECK_EQUAL(upperClosedNeighbours.size(), 3ul);
0045   BOOST_CHECK_EQUAL(upperClosedNeighbours[0ul], 9ul);
0046   BOOST_CHECK_EQUAL(upperClosedNeighbours[1ul], 10ul);
0047   BOOST_CHECK_EQUAL(upperClosedNeighbours[2ul], 1ul);
0048
0049   // For Open Boundary [default]: out-of-bounds lookups resolve to dedicated
0050   // underflow and overflow bins.
0051   Acts::detail::Axis<Acts::detail::AxisType::Equidistant,
0052                      Acts::detail::AxisBoundaryType::Open>
0053       xAxisOpen(0, 100, nBins);
0054   Acts::Grid<double, decltype(xAxisOpen)> gridOpen(
0055       std::make_tuple(std::move(xAxisOpen)));
0056
0057   auto lowerOpenNeighbours = binFinder.findBins(lowerBound, gridOpen);
0058   BOOST_CHECK_EQUAL(lowerOpenNeighbours.size(), 3ul);
0059   BOOST_CHECK_EQUAL(lowerOpenNeighbours[0ul], 0ul);
0060   BOOST_CHECK_EQUAL(lowerOpenNeighbours[1ul], 1ul);
0061   BOOST_CHECK_EQUAL(lowerOpenNeighbours[2ul], 2ul);
0062
0063   auto upperOpenNeighbours = binFinder.findBins(upperBound, gridOpen);
0064   BOOST_CHECK_EQUAL(upperOpenNeighbours.size(), 3ul);
0065   BOOST_CHECK_EQUAL(upperOpenNeighbours[0ul], 9ul);
0066   BOOST_CHECK_EQUAL(upperOpenNeighbours[1ul], 10ul);
0067   BOOST_CHECK_EQUAL(upperOpenNeighbours[2ul], 11ul);
0068
0069   // For Bound Boundary: out-of-bounds lookups resolve to the closest valid bin.
0070   Acts::detail::Axis<Acts::detail::AxisType::Equidistant,
0071                      Acts::detail::AxisBoundaryType::Bound>
0072       xAxisBound(0, 100, nBins);
0073   Acts::Grid<double, decltype(xAxisBound)> gridBound(
0074       std::make_tuple(std::move(xAxisBound)));
0075
0076   auto lowerBoundNeighbours = binFinder.findBins(lowerBound, gridBound);
0077   BOOST_CHECK_EQUAL(lowerBoundNeighbours.size(), 2ul);
0078   BOOST_CHECK_EQUAL(lowerBoundNeighbours[0ul], 1ul);
0079   BOOST_CHECK_EQUAL(lowerBoundNeighbours[1ul], 2ul);
0080
0081   auto upperBoundNeighbours = binFinder.findBins(upperBound, gridBound);
0082   BOOST_CHECK_EQUAL(upperBoundNeighbours.size(), 2ul);
0083   BOOST_CHECK_EQUAL(upperBoundNeighbours[0ul], 9ul);
0084   BOOST_CHECK_EQUAL(upperBoundNeighbours[1ul], 10ul);
0085 }
0086
0087 BOOST_AUTO_TEST_CASE(grid_binfinder_constructor) {
0088   using list_t = std::vector<std::pair<int, int>>;
0089   Acts::GridBinFinder<1ul> binFinder_1d_1(1);
0090   Acts::GridBinFinder<1ul> binFinder_1d_2(list_t({}));
0091   Acts::GridBinFinder<1ul> binFinder_1d_3(list_t({{0, 2}, {-1, 1}}));
0092   Acts::GridBinFinder<1ul> binFinder_1d_4(std::make_pair(1, 1));
0093
0094   Acts::GridBinFinder<2ul> binFinder_2d_1(1, 5);
0095   Acts::GridBinFinder<2ul> binFinder_2d_2(list_t({}),
0096                                           list_t({{0, 2}, {-1, 1}}));
0097   Acts::GridBinFinder<2ul> binFinder_2d_3(list_t({}), 2);
0098   Acts::GridBinFinder<2ul> binFinder_2d_4(std::make_pair(1, 2), 2);
0099
0100   Acts::GridBinFinder<3ul> binFinder_3d_1(1, 1, 5);
0101
0102   Acts::GridBinFinder<10ul> binFinder_10d_1(1, 1, 5, 0, 4, 2, 3, 1, 1, 9);
0103 }
0104
0105 BOOST_AUTO_TEST_CASE(grid_binfinder_test_1d_ints) {
0106   const std::size_t nBins = 10ul;
0107   Acts::detail::EquidistantAxis xAxis(0, 100, nBins);
0108   Acts::Grid<double, Acts::detail::EquidistantAxis> grid(
0109       std::make_tuple(std::move(xAxis)));
0110
0111   std::array<std::size_t, 1ul> locPosition({3ul});
0112
0113   Acts::GridBinFinder<1ul> binFinder_1(1);
0114   auto neighbours_1 = binFinder_1.findBins(locPosition, grid);
0115   BOOST_CHECK_EQUAL(neighbours_1.size(), 3ul);
0116
0117   for (const std::size_t neighbour : neighbours_1) {
0118     std::array<std::size_t, 1ul> neighboutLocPosition =
0119         grid.localBinsFromGlobalBin(neighbour);
0120     std::size_t distance = locPosition[0ul] <= neighboutLocPosition[0ul]
0121                                ? neighboutLocPosition[0ul] - locPosition[0ul]
0122                                : locPosition[0ul] - neighboutLocPosition[0ul];
0123     BOOST_CHECK(distance <= 1ul);
0124   }
0125
0126   Acts::GridBinFinder<1ul> binFinder_2(2);
0127   auto neighbours_2 = binFinder_2.findBins(locPosition, grid);
0128   BOOST_CHECK_EQUAL(neighbours_2.size(), 5ul);
0129
0130   for (const std::size_t neighbour : neighbours_2) {
0131     std::array<std::size_t, 1ul> neighboutLocPosition =
0132         grid.localBinsFromGlobalBin(neighbour);
0133     std::size_t distance = locPosition[0ul] <= neighboutLocPosition[0ul]
0134                                ? neighboutLocPosition[0ul] - locPosition[0ul]
0135                                : locPosition[0ul] - neighboutLocPosition[0ul];
0136     BOOST_CHECK(distance <= 2ul);
0137   }
0138 }
0139
0140 BOOST_AUTO_TEST_CASE(grid_binfinder_test_2d_ints) {
0141   const std::size_t nBinsX = 10ul;
0142   const std::size_t nBinsY = 10ul;
0143   Acts::detail::EquidistantAxis xAxis(0, 100, nBinsX);
0144   Acts::detail::EquidistantAxis yAxis(0, 100, nBinsY);
0145   Acts::Grid<double, Acts::detail::EquidistantAxis,
0146              Acts::detail::EquidistantAxis>
0147       grid(std::make_tuple(std::move(xAxis), std::move(yAxis)));
0148
0149   std::array<std::size_t, 2ul> locPosition({3ul, 6ul});
0150
0151   Acts::GridBinFinder<2ul> binFinder_1(1, 3);
0152   std::array<std::size_t, 2ul> dims_1({1, 3});
0153   auto neighbours_1 = binFinder_1.findBins(locPosition, grid);
0154   BOOST_CHECK_EQUAL(neighbours_1.size(), 3ul * 7ul);
0155
0156   for (const std::size_t neighbour : neighbours_1) {
0157     std::array<std::size_t, 2ul> neighboutLocPosition =
0158         grid.localBinsFromGlobalBin(neighbour);
0159     for (std::size_t dim(0ul); dim < 2ul; ++dim) {
0160       std::size_t distance = locPosition[dim] <= neighboutLocPosition[dim]
0161                                  ? neighboutLocPosition[dim] - locPosition[dim]
0162                                  : locPosition[dim] - neighboutLocPosition[dim];
0163       BOOST_CHECK(distance <= dims_1[dim]);
0164     }
0165   }
0166
0167   Acts::GridBinFinder<2ul> binFinder_2(2, 1);
0168   std::array<std::size_t, 2ul> dims_2({2, 1});
0169   auto neighbours_2 = binFinder_2.findBins(locPosition, grid);
0170   BOOST_CHECK_EQUAL(neighbours_2.size(), 5ul * 3ul);
0171
0172   for (const std::size_t neighbour : neighbours_2) {
0173     std::array<std::size_t, 2ul> neighboutLocPosition =
0174         grid.localBinsFromGlobalBin(neighbour);
0175     for (std::size_t dim(0ul); dim < 2ul; ++dim) {
0176       std::size_t distance = locPosition[dim] <= neighboutLocPosition[dim]
0177                                  ? neighboutLocPosition[dim] - locPosition[dim]
0178                                  : locPosition[dim] - neighboutLocPosition[dim];
0179       BOOST_CHECK(distance <= dims_2[dim]);
0180     }
0181   }
0182 }
0183
0184 BOOST_AUTO_TEST_CASE(grid_binfinder_test_3d_ints) {
0185   const std::size_t nBinsX = 10ul;
0186   const std::size_t nBinsY = 10ul;
0187   const std::size_t nBinsZ = 3ul;
0188   Acts::detail::EquidistantAxis xAxis(0, 100, nBinsX);
0189   Acts::detail::EquidistantAxis yAxis(0, 100, nBinsY);
0190   Acts::detail::EquidistantAxis zAxis(0, 100, nBinsZ);
0191   Acts::Grid<double, Acts::detail::EquidistantAxis,
0192              Acts::detail::EquidistantAxis, Acts::detail::EquidistantAxis>
0193       grid(std::make_tuple(std::move(xAxis), std::move(yAxis),
0194                            std::move(zAxis)));
0195
0196   std::array<std::size_t, 3ul> locPosition({3ul, 6ul, 2ul});
0197
0198   Acts::GridBinFinder<3ul> binFinder(1, 2, 0);
0199   std::array<std::size_t, 3ul> dims({1, 2, 0});
0200   auto neighbours = binFinder.findBins(locPosition, grid);
0201   BOOST_CHECK_EQUAL(neighbours.size(), 3ul * 5ul * 1ul);
0202
0203   for (const std::size_t neighbour : neighbours) {
0204     std::array<std::size_t, 3ul> neighboutLocPosition =
0205         grid.localBinsFromGlobalBin(neighbour);
0206     for (std::size_t dim(0ul); dim < 3ul; ++dim) {
0207       std::size_t distance = locPosition[dim] <= neighboutLocPosition[dim]
0208                                  ? neighboutLocPosition[dim] - locPosition[dim]
0209                                  : locPosition[dim] - neighboutLocPosition[dim];
0210       BOOST_CHECK(distance <= dims[dim]);
0211     }
0212   }
0213 }
0214
0215 BOOST_AUTO_TEST_CASE(grid_binfinder_test_1d_pair) {
0216   const std::size_t nBins = 10ul;
0217   Acts::detail::EquidistantAxis xAxis(0, 100, nBins);
0218   Acts::Grid<double, Acts::detail::EquidistantAxis> grid(
0219       std::make_tuple(std::move(xAxis)));
0220
0221   std::array<std::size_t, 1ul> locPosition({3ul});
0222
0223   Acts::GridBinFinder<1ul> binFinder_1(std::make_pair(1, 1));
0224   auto neighbours_1 = binFinder_1.findBins(locPosition, grid);
0225   BOOST_CHECK_EQUAL(neighbours_1.size(), 3ul);
0226
0227   for (const std::size_t neighbour : neighbours_1) {
0228     std::array<std::size_t, 1ul> neighboutLocPosition =
0229         grid.localBinsFromGlobalBin(neighbour);
0230     std::size_t distance = locPosition[0ul] <= neighboutLocPosition[0ul]
0231                                ? neighboutLocPosition[0ul] - locPosition[0ul]
0232                                : locPosition[0ul] - neighboutLocPosition[0ul];
0233     BOOST_CHECK(distance <= 1ul);
0234   }
0235
0236   Acts::GridBinFinder<1ul> binFinder_2(std::make_pair(2, 2));
0237   auto neighbours_2 = binFinder_2.findBins(locPosition, grid);
0238   BOOST_CHECK_EQUAL(neighbours_2.size(), 5ul);
0239
0240   for (const std::size_t neighbour : neighbours_2) {
0241     std::array<std::size_t, 1ul> neighboutLocPosition =
0242         grid.localBinsFromGlobalBin(neighbour);
0243     std::size_t distance = locPosition[0ul] <= neighboutLocPosition[0ul]
0244                                ? neighboutLocPosition[0ul] - locPosition[0ul]
0245                                : locPosition[0ul] - neighboutLocPosition[0ul];
0246     BOOST_CHECK(distance <= 2ul);
0247   }
0248 }
0249
0250 BOOST_AUTO_TEST_CASE(grid_binfinder_test_1d_pair_asymmetric) {
0251   const std::size_t nBins = 10ul;
0252   Acts::detail::EquidistantAxis xAxis(0, 100, nBins);
0253   Acts::Grid<double, Acts::detail::EquidistantAxis> grid(
0254       std::make_tuple(std::move(xAxis)));
0255
0256   std::array<std::size_t, 1ul> locPosition({3ul});
0257
0258   Acts::GridBinFinder<1ul> binFinder_1(std::make_pair(1, 2));
0259   auto neighbours_1 = binFinder_1.findBins(locPosition, grid);
0260   BOOST_CHECK_EQUAL(neighbours_1.size(), 4ul);
0261
0262   std::array<std::size_t, 4ul> expected({2ul, 3ul, 4ul, 5ul});
0263   for (std::size_t i(0ul); i < 4ul; ++i) {
0264     BOOST_CHECK_EQUAL(neighbours_1[i], expected[i]);
0265   }
0266 }
0267
0268 BOOST_AUTO_TEST_CASE(grid_binfinder_test_2d_pair) {
0269   const std::size_t nBinsX = 10ul;
0270   const std::size_t nBinsY = 10ul;
0271   Acts::detail::EquidistantAxis xAxis(0, 100, nBinsX);
0272   Acts::detail::EquidistantAxis yAxis(0, 100, nBinsY);
0273   Acts::Grid<double, Acts::detail::EquidistantAxis,
0274              Acts::detail::EquidistantAxis>
0275       grid(std::make_tuple(std::move(xAxis), std::move(yAxis)));
0276
0277   std::array<std::size_t, 2ul> locPosition({3ul, 6ul});
0278
0279   Acts::GridBinFinder<2ul> binFinder_1(std::make_pair(1, 1),
0280                                        std::make_pair(3, 3));
0281   std::array<std::size_t, 2ul> dims_1({1, 3});
0282   auto neighbours_1 = binFinder_1.findBins(locPosition, grid);
0283   BOOST_CHECK_EQUAL(neighbours_1.size(), 3ul * 7ul);
0284
0285   for (const std::size_t neighbour : neighbours_1) {
0286     std::array<std::size_t, 2ul> neighboutLocPosition =
0287         grid.localBinsFromGlobalBin(neighbour);
0288     for (std::size_t dim(0ul); dim < 2ul; ++dim) {
0289       std::size_t distance = locPosition[dim] <= neighboutLocPosition[dim]
0290                                  ? neighboutLocPosition[dim] - locPosition[dim]
0291                                  : locPosition[dim] - neighboutLocPosition[dim];
0292       BOOST_CHECK(distance <= dims_1[dim]);
0293     }
0294   }
0295
0296   Acts::GridBinFinder<2ul> binFinder_2(std::make_pair(2, 2),
0297                                        std::make_pair(1, 1));
0298   std::array<std::size_t, 2ul> dims_2({2, 1});
0299   auto neighbours_2 = binFinder_2.findBins(locPosition, grid);
0300   BOOST_CHECK_EQUAL(neighbours_2.size(), 5ul * 3ul);
0301
0302   for (const std::size_t neighbour : neighbours_2) {
0303     std::array<std::size_t, 2ul> neighboutLocPosition =
0304         grid.localBinsFromGlobalBin(neighbour);
0305     for (std::size_t dim(0ul); dim < 2ul; ++dim) {
0306       std::size_t distance = locPosition[dim] <= neighboutLocPosition[dim]
0307                                  ? neighboutLocPosition[dim] - locPosition[dim]
0308                                  : locPosition[dim] - neighboutLocPosition[dim];
0309       BOOST_CHECK(distance <= dims_2[dim]);
0310     }
0311   }
0312 }
0313
0314 BOOST_AUTO_TEST_CASE(grid_binfinder_test_1d_pattern) {
0315   const std::size_t nBins = 5ul;
0316   Acts::detail::EquidistantAxis xAxis(0, 100, nBins);
0317   Acts::Grid<double, Acts::detail::EquidistantAxis> grid(
0318       std::make_tuple(std::move(xAxis)));
0319
0320   std::array<std::vector<std::size_t>, 1ul> navigation;
0321   navigation[0ul].resize(nBins);
0322   std::iota(navigation[0ul].begin(), navigation[0ul].end(), 1ul);
0323
0324   std::vector<std::pair<int, int>> neighbours;
0325   neighbours.push_back(std::make_pair(0, 2));
0326   neighbours.push_back(std::make_pair(-1, 1));
0327   neighbours.push_back(std::make_pair(-1, 2));
0328   neighbours.push_back(std::make_pair(-2, 1));
0329   neighbours.push_back(std::make_pair(-1, 0));
0330
0331   BOOST_CHECK_EQUAL(neighbours.size(), grid.numLocalBins()[0ul]);
0332
0333   auto startGrid = grid.begin(navigation);
0334   auto stopGrid = grid.end(navigation);
0335
0336   Acts::GridBinFinder<1ul> binFinder(std::move(neighbours));
0337
0338   std::size_t counter = 0ul;
0339   std::vector<std::size_t> expectedNeighbours = {3, 3, 4, 4, 2};
0340
0341   for (; startGrid != stopGrid; startGrid++) {
0342     std::array<std::size_t, 1ul> locPosition = startGrid.localBinsIndices();
0343     auto all_neigh = binFinder.findBins(locPosition, grid);
0344     BOOST_CHECK_EQUAL(all_neigh.size(), expectedNeighbours[counter++]);
0345   }
0346
0347   std::vector<std::pair<int, int>> anotherNeighbours;
0348   anotherNeighbours.push_back(std::make_pair(1, 2));
0349   anotherNeighbours.push_back(std::make_pair(-1, 1));
0350   anotherNeighbours.push_back(std::make_pair(-1, 2));
0351   anotherNeighbours.push_back(std::make_pair(-2, 1));
0352   anotherNeighbours.push_back(std::make_pair(-1, 0));
0353
0354   Acts::GridBinFinder<1ul> anotherBinFinder(std::move(anotherNeighbours));
0355   std::array<std::size_t, 1ul> locPosition = {1ul};
0356
0357   auto neighs = anotherBinFinder.findBins(locPosition, grid);
0358   BOOST_CHECK_EQUAL(neighs.size(), 2ul);
0359
0360   for (const std::size_t neighbour : neighs) {
0361     std::array<std::size_t, 1ul> neighboutLocPosition =
0362         grid.localBinsFromGlobalBin(neighbour);
0363     std::size_t distance = locPosition[0ul] <= neighboutLocPosition[0ul]
0364                                ? neighboutLocPosition[0ul] - locPosition[0ul]
0365                                : locPosition[0ul] - neighboutLocPosition[0ul];
0366     BOOST_CHECK(distance <= 2ul);
0367     BOOST_CHECK(distance >= 1ul);
0368   }
0369 }
0370
0371 BOOST_AUTO_TEST_CASE(grid_binfinder_test_2d_pattern) {
0372   const std::size_t nBinsX = 5ul;
0373   const std::size_t nBinsY = 3ul;
0374   Acts::detail::EquidistantAxis xAxis(0, 100, nBinsX);
0375   Acts::detail::EquidistantAxis yAxis(0, 100, nBinsY);
0376   Acts::Grid<double, Acts::detail::EquidistantAxis,
0377              Acts::detail::EquidistantAxis>
0378       grid(std::make_tuple(std::move(xAxis), std::move(yAxis)));
0379
0380   std::array<std::vector<std::size_t>, 2ul> navigation;
0381   navigation[0ul].resize(nBinsX);
0382   navigation[1ul].resize(nBinsY);
0383   std::iota(navigation[0ul].begin(), navigation[0ul].end(), 1ul);
0384   std::iota(navigation[1ul].begin(), navigation[1ul].end(), 1ul);
0385
0386   std::vector<std::pair<int, int>> neighboursX;
0387   neighboursX.push_back(std::make_pair(0, 2));
0388   neighboursX.push_back(std::make_pair(-1, 1));
0389   neighboursX.push_back(std::make_pair(-1, 2));
0390   neighboursX.push_back(std::make_pair(-2, 1));
0391   neighboursX.push_back(std::make_pair(-1, 0));
0392
0393   std::vector<std::pair<int, int>> neighboursY;
0394   neighboursY.push_back(std::make_pair(0, 1));
0395   neighboursY.push_back(std::make_pair(-1, 1));
0396   neighboursY.push_back(std::make_pair(-1, 0));
0397
0398   BOOST_CHECK_EQUAL(neighboursX.size(), grid.numLocalBins()[0ul]);
0399   BOOST_CHECK_EQUAL(neighboursY.size(), grid.numLocalBins()[1ul]);
0400
0401   auto startGrid = grid.begin(navigation);
0402   auto stopGrid = grid.end(navigation);
0403
0404   std::size_t counter = 0ul;
0405   std::vector<std::size_t> expectedNeighbours = {6, 9, 6,  6, 9, 6, 8, 12,
0406                                                  8, 8, 12, 8, 4, 6, 4};
0407
0408   BOOST_CHECK_EQUAL(expectedNeighbours.size(),
0409                     neighboursX.size() * neighboursY.size());
0410
0411   Acts::GridBinFinder<2ul> binFinder(std::move(neighboursX),
0412                                      std::move(neighboursY));
0413
0414   for (; startGrid != stopGrid; startGrid++) {
0415     std::array<std::size_t, 2ul> locPosition = startGrid.localBinsIndices();
0416     auto all_neigh = binFinder.findBins(locPosition, grid);
0417     BOOST_CHECK_EQUAL(all_neigh.size(), expectedNeighbours[counter++]);
0418   }
0419 }
0420
0421 BOOST_AUTO_TEST_CASE(grid_binfinder_test_2d_empty_pattern) {
0422   const std::size_t nBinsX = 5ul;
0423   const std::size_t nBinsY = 3ul;
0424   Acts::detail::EquidistantAxis xAxis(0, 100, nBinsX);
0425   Acts::detail::EquidistantAxis yAxis(0, 100, nBinsY);
0426   Acts::Grid<double, Acts::detail::EquidistantAxis,
0427              Acts::detail::EquidistantAxis>
0428       grid(std::make_tuple(std::move(xAxis), std::move(yAxis)));
0429
0430   std::array<std::vector<std::size_t>, 2ul> navigation;
0431   navigation[0ul].resize(nBinsX);
0432   navigation[1ul].resize(nBinsY);
0433   std::iota(navigation[0ul].begin(), navigation[0ul].end(), 1ul);
0434   std::iota(navigation[1ul].begin(), navigation[1ul].end(), 1ul);
0435
0436   std::vector<std::pair<int, int>> neighboursX;
0437   std::vector<std::pair<int, int>> neighboursY;
0438
0439   auto startGrid = grid.begin(navigation);
0440   auto stopGrid = grid.end(navigation);
0441
0442   Acts::GridBinFinder<2ul> binFinder(std::move(neighboursX),
0443                                      std::move(neighboursY));
0444
0445   for (; startGrid != stopGrid; startGrid++) {
0446     std::array<std::size_t, 2ul> locPosition = startGrid.localBinsIndices();
0447     auto all_neigh = binFinder.findBins(locPosition, grid);
0448     BOOST_CHECK_EQUAL(all_neigh.size(), 9ul);
0449   }
0450 }
0451
0452 BOOST_AUTO_TEST_CASE(grid_binfinder_test_2d_mixed) {
0453   const std::size_t nBinsX = 5ul;
0454   const std::size_t nBinsY = 3ul;
0455   Acts::detail::EquidistantAxis xAxis(0, 100, nBinsX);
0456   Acts::detail::EquidistantAxis yAxis(0, 100, nBinsY);
0457   Acts::Grid<double, Acts::detail::EquidistantAxis,
0458              Acts::detail::EquidistantAxis>
0459       grid(std::make_tuple(std::move(xAxis), std::move(yAxis)));
0460
0461   std::array<std::vector<std::size_t>, 2ul> navigation;
0462   navigation[0ul].resize(nBinsX);
0463   navigation[1ul].resize(nBinsY);
0464   std::iota(navigation[0ul].begin(), navigation[0ul].end(), 1ul);
0465   std::iota(navigation[1ul].begin(), navigation[1ul].end(), 1ul);
0466
0467   std::vector<std::pair<int, int>> neighboursX;
0468   neighboursX.push_back(std::make_pair(0, 2));
0469   neighboursX.push_back(std::make_pair(-1, 1));
0470   neighboursX.push_back(std::make_pair(-1, 2));
0471   neighboursX.push_back(std::make_pair(-2, 1));
0472   neighboursX.push_back(std::make_pair(-1, 0));
0473
0474   BOOST_CHECK_EQUAL(neighboursX.size(), grid.numLocalBins()[0ul]);
0475
0476   auto startGrid = grid.begin(navigation);
0477   auto stopGrid = grid.end(navigation);
0478
0479   std::size_t counter = 0ul;
0480   std::vector<std::size_t> expectedNeighbours = {9,  9,  9,  9,  9, 9, 12, 12,
0481                                                  12, 12, 12, 12, 6, 6, 6};
0482
0483   BOOST_CHECK_EQUAL(expectedNeighbours.size(), neighboursX.size() * nBinsY);
0484
0485   Acts::GridBinFinder<2ul> binFinder(std::move(neighboursX), 1);
0486
0487   for (; startGrid != stopGrid; startGrid++) {
0488     std::array<std::size_t, 2ul> locPosition = startGrid.localBinsIndices();
0489     auto all_neigh = binFinder.findBins(locPosition, grid);
0490     BOOST_CHECK_EQUAL(all_neigh.size(), expectedNeighbours[counter++]);
0491   }
0492 }
0493
0494 }  // namespace Acts::Test