Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-10-24 08:20:42 

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 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 https://mozilla.org/MPL/2.0/.
0008 
0009 #include <boost/test/unit_test.hpp>
0010 
0011 #include "Acts/Definitions/Algebra.hpp"
0012 #include "Acts/Utilities/Axis.hpp"
0013 #include "Acts/Utilities/AxisDefinitions.hpp"
0014 #include "Acts/Utilities/Grid.hpp"
0015 #include "Acts/Utilities/detail/grid_helper.hpp"
0016 #include "ActsTests/CommonHelpers/FloatComparisons.hpp"
0017 
0018 #include <algorithm>
0019 #include <array>
0020 #include <concepts>
0021 #include <cstddef>
0022 #include <set>
0023 #include <string>
0024 #include <tuple>
0025 #include <utility>
0026 #include <vector>
0027 
0028 using namespace Acts;
0029 using namespace Acts::detail;
0030 
0031 namespace ActsTests {
0032 
0033 BOOST_AUTO_TEST_SUITE(UtilitiesSuite)
0034 
0035 BOOST_AUTO_TEST_CASE(grid_test_1d_equidistant) {
0036   using Point = std::array<double, 1>;
0037   using indices = std::array<std::size_t, 1>;
0038   Axis a(0.0, 4.0, 4u);
0039   Grid g(Type<double>, std::move(a));
0040 
0041   // test general properties
0042   BOOST_CHECK_EQUAL(g.size(), 6u);
0043   BOOST_CHECK_EQUAL(g.numLocalBins().at(0), 4u);
0044 
0045   // global bin index
0046   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-0.3}})), 0u);
0047   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-0.}})), 1u);
0048   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.}})), 1u);
0049   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.7}})), 1u);
0050   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1}})), 2u);
0051   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1.2}})), 2u);
0052   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2.}})), 3u);
0053   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2.7}})), 3u);
0054   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3.}})), 4u);
0055   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3.9999}})), 4u);
0056   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4.}})), 5u);
0057   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4.98}})), 5u);
0058 
0059   // global bin index -> local bin indices
0060   BOOST_CHECK(g.localBinsFromGlobalBin(0) == indices({{0}}));
0061   BOOST_CHECK(g.localBinsFromGlobalBin(1) == indices({{1}}));
0062   BOOST_CHECK(g.localBinsFromGlobalBin(2) == indices({{2}}));
0063   BOOST_CHECK(g.localBinsFromGlobalBin(3) == indices({{3}}));
0064   BOOST_CHECK(g.localBinsFromGlobalBin(4) == indices({{4}}));
0065   BOOST_CHECK(g.localBinsFromGlobalBin(5) == indices({{5}}));
0066 
0067   // local bin indices -> global bin index
0068   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0}}), 0u);
0069   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1}}), 1u);
0070   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2}}), 2u);
0071   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3}}), 3u);
0072   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4}}), 4u);
0073   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5}}), 5u);
0074 
0075   BOOST_CHECK(g.localBinsFromGlobalBin(
0076                   g.globalBinFromPosition(Point({{2.7}}))) == indices({{3}}));
0077 
0078   // inside checks
0079   BOOST_CHECK(!g.isInside(Point({{-2.}})));
0080   BOOST_CHECK(g.isInside(Point({{0.}})));
0081   BOOST_CHECK(g.isInside(Point({{2.5}})));
0082   BOOST_CHECK(!g.isInside(Point({{4.}})));
0083   BOOST_CHECK(!g.isInside(Point({{6.}})));
0084 
0085   // test some bin centers
0086   CHECK_CLOSE_ABS(g.binCenter({{1}}), Point({{0.5}}), 1e-6);
0087   CHECK_CLOSE_ABS(g.binCenter({{2}}), Point({{1.5}}), 1e-6);
0088   CHECK_CLOSE_ABS(g.binCenter({{3}}), Point({{2.5}}), 1e-6);
0089   CHECK_CLOSE_ABS(g.binCenter({{4}}), Point({{3.5}}), 1e-6);
0090 
0091   // test some lower-left bin edges
0092   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1}}), Point({{0.}}), 1e-6);
0093   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2}}), Point({{1.}}), 1e-6);
0094   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{3}}), Point({{2.}}), 1e-6);
0095   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{4}}), Point({{3.}}), 1e-6);
0096 
0097   // test some upper right-bin edges
0098   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1}}), Point({{1.}}), 1e-6);
0099   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2}}), Point({{2.}}), 1e-6);
0100   CHECK_CLOSE_ABS(g.upperRightBinEdge({{3}}), Point({{3.}}), 1e-6);
0101   CHECK_CLOSE_ABS(g.upperRightBinEdge({{4}}), Point({{4.}}), 1e-6);
0102 
0103   // initialize grid
0104   for (std::size_t bin = 0; bin < g.size(); ++bin) {
0105     g.at(bin) = bin;
0106   }
0107 
0108   // consistency of access
0109   const auto& point = Point({{0.7}});
0110   std::size_t globalBin = g.globalBinFromPosition(point);
0111   indices localBins = g.localBinsFromGlobalBin(globalBin);
0112 
0113   BOOST_CHECK_EQUAL(g.atPosition(point), g.at(globalBin));
0114   BOOST_CHECK_EQUAL(g.atPosition(point), g.atLocalBins(localBins));
0115 }
0116 
0117 BOOST_AUTO_TEST_CASE(grid_test_2d_equidistant) {
0118   using Point = std::array<double, 2>;
0119   using indices = std::array<std::size_t, 2>;
0120   Axis a(0.0, 4.0, 4u);
0121   Axis b(0.0, 3.0, 3u);
0122   Grid g(Type<double>, std::move(a), std::move(b));
0123 
0124   // test general properties
0125   BOOST_CHECK_EQUAL(g.size(), 30u);
0126   BOOST_CHECK_EQUAL(g.numLocalBins().at(0), 4u);
0127   BOOST_CHECK_EQUAL(g.numLocalBins().at(1), 3u);
0128 
0129   // global bin index
0130   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-1, -1}})), 0u);
0131   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-1, 0}})), 1u);
0132   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-1, 1}})), 2u);
0133   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-1, 2}})), 3u);
0134   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-1, 3}})), 4u);
0135   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, -1}})), 5u);
0136   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0}})), 6u);
0137   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 1}})), 7u);
0138   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 2}})), 8u);
0139   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3}})), 9u);
0140   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, -1}})), 10u);
0141   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0}})), 11u);
0142   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 1}})), 12u);
0143   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 2}})), 13u);
0144   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3}})), 14u);
0145   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, -1}})), 15u);
0146   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 0}})), 16u);
0147   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 1}})), 17u);
0148   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 2}})), 18u);
0149   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 3}})), 19u);
0150   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, -1}})), 20u);
0151   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 0}})), 21u);
0152   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 1}})), 22u);
0153   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 2}})), 23u);
0154   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 3}})), 24u);
0155   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4, -1}})), 25u);
0156   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4, 0}})), 26u);
0157   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4, 1}})), 27u);
0158   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4, 2}})), 28u);
0159   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4, 3}})), 29u);
0160 
0161   // test some arbitrary points
0162   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1.2, 0.3}})), 11u);
0163   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2.2, 3.3}})), 19u);
0164   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.9, 1.8}})), 7u);
0165   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3.7, 3.1}})), 24u);
0166   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1.4, 2.3}})), 13u);
0167   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-3, 3}})), 4u);
0168   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{8, 1}})), 27u);
0169   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, -3}})), 10u);
0170   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 11}})), 24u);
0171   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-2, -3}})), 0u);
0172   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-2, 7}})), 04u);
0173   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{12, -1}})), 25u);
0174   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{12, 11}})), 29u);
0175 
0176   // global bin index -> local bin indices
0177   BOOST_CHECK(g.localBinsFromGlobalBin(0) == indices({{0, 0}}));
0178   BOOST_CHECK(g.localBinsFromGlobalBin(1) == indices({{0, 1}}));
0179   BOOST_CHECK(g.localBinsFromGlobalBin(2) == indices({{0, 2}}));
0180   BOOST_CHECK(g.localBinsFromGlobalBin(3) == indices({{0, 3}}));
0181   BOOST_CHECK(g.localBinsFromGlobalBin(4) == indices({{0, 4}}));
0182   BOOST_CHECK(g.localBinsFromGlobalBin(5) == indices({{1, 0}}));
0183   BOOST_CHECK(g.localBinsFromGlobalBin(6) == indices({{1, 1}}));
0184   BOOST_CHECK(g.localBinsFromGlobalBin(7) == indices({{1, 2}}));
0185   BOOST_CHECK(g.localBinsFromGlobalBin(8) == indices({{1, 3}}));
0186   BOOST_CHECK(g.localBinsFromGlobalBin(9) == indices({{1, 4}}));
0187   BOOST_CHECK(g.localBinsFromGlobalBin(10) == indices({{2, 0}}));
0188   BOOST_CHECK(g.localBinsFromGlobalBin(11) == indices({{2, 1}}));
0189   BOOST_CHECK(g.localBinsFromGlobalBin(12) == indices({{2, 2}}));
0190   BOOST_CHECK(g.localBinsFromGlobalBin(13) == indices({{2, 3}}));
0191   BOOST_CHECK(g.localBinsFromGlobalBin(14) == indices({{2, 4}}));
0192   BOOST_CHECK(g.localBinsFromGlobalBin(15) == indices({{3, 0}}));
0193   BOOST_CHECK(g.localBinsFromGlobalBin(16) == indices({{3, 1}}));
0194   BOOST_CHECK(g.localBinsFromGlobalBin(17) == indices({{3, 2}}));
0195   BOOST_CHECK(g.localBinsFromGlobalBin(18) == indices({{3, 3}}));
0196   BOOST_CHECK(g.localBinsFromGlobalBin(19) == indices({{3, 4}}));
0197   BOOST_CHECK(g.localBinsFromGlobalBin(20) == indices({{4, 0}}));
0198   BOOST_CHECK(g.localBinsFromGlobalBin(21) == indices({{4, 1}}));
0199   BOOST_CHECK(g.localBinsFromGlobalBin(22) == indices({{4, 2}}));
0200   BOOST_CHECK(g.localBinsFromGlobalBin(23) == indices({{4, 3}}));
0201   BOOST_CHECK(g.localBinsFromGlobalBin(24) == indices({{4, 4}}));
0202   BOOST_CHECK(g.localBinsFromGlobalBin(25) == indices({{5, 0}}));
0203   BOOST_CHECK(g.localBinsFromGlobalBin(26) == indices({{5, 1}}));
0204   BOOST_CHECK(g.localBinsFromGlobalBin(27) == indices({{5, 2}}));
0205   BOOST_CHECK(g.localBinsFromGlobalBin(28) == indices({{5, 3}}));
0206   BOOST_CHECK(g.localBinsFromGlobalBin(29) == indices({{5, 4}}));
0207 
0208   // local bin indices -> global bin index
0209   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0}}), 0u);
0210   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1}}), 1u);
0211   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 2}}), 2u);
0212   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 3}}), 3u);
0213   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 4}}), 4u);
0214   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 0}}), 5u);
0215   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1}}), 6u);
0216   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 2}}), 7u);
0217   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 3}}), 8u);
0218   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 4}}), 9u);
0219   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 0}}), 10u);
0220   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 1}}), 11u);
0221   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 2}}), 12u);
0222   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3}}), 13u);
0223   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 4}}), 14u);
0224   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 0}}), 15u);
0225   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 1}}), 16u);
0226   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 2}}), 17u);
0227   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 3}}), 18u);
0228   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 4}}), 19u);
0229   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 0}}), 20u);
0230   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 1}}), 21u);
0231   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 2}}), 22u);
0232   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 3}}), 23u);
0233   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 4}}), 24u);
0234   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 0}}), 25u);
0235   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 1}}), 26u);
0236   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 2}}), 27u);
0237   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 3}}), 28u);
0238   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 4}}), 29u);
0239 
0240   BOOST_CHECK(g.localBinsFromGlobalBin(g.globalBinFromPosition(
0241                   Point({{1.2, 0.7}}))) == indices({{2, 1}}));
0242 
0243   // inside checks
0244   BOOST_CHECK(!g.isInside(Point({{-2., -1}})));
0245   BOOST_CHECK(!g.isInside(Point({{-2., 1.}})));
0246   BOOST_CHECK(!g.isInside(Point({{-2., 5.}})));
0247   BOOST_CHECK(!g.isInside(Point({{1., -1.}})));
0248   BOOST_CHECK(!g.isInside(Point({{6., -1.}})));
0249   BOOST_CHECK(g.isInside(Point({{0.5, 1.3}})));
0250   BOOST_CHECK(!g.isInside(Point({{4., -1.}})));
0251   BOOST_CHECK(!g.isInside(Point({{4., 0.3}})));
0252   BOOST_CHECK(!g.isInside(Point({{4., 3.}})));
0253   BOOST_CHECK(!g.isInside(Point({{-1., 3.}})));
0254   BOOST_CHECK(!g.isInside(Point({{2., 3.}})));
0255   BOOST_CHECK(!g.isInside(Point({{5., 3.}})));
0256 
0257   // test some bin centers
0258   CHECK_CLOSE_ABS(g.binCenter({{1, 1}}), Point({{0.5, 0.5}}), 1e-6);
0259   CHECK_CLOSE_ABS(g.binCenter({{2, 3}}), Point({{1.5, 2.5}}), 1e-6);
0260   CHECK_CLOSE_ABS(g.binCenter({{3, 1}}), Point({{2.5, 0.5}}), 1e-6);
0261   CHECK_CLOSE_ABS(g.binCenter({{4, 2}}), Point({{3.5, 1.5}}), 1e-6);
0262 
0263   // test some lower-left bin edges
0264   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1}}), Point({{0., 0.}}), 1e-6);
0265   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2, 3}}), Point({{1., 2.}}), 1e-6);
0266   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{3, 1}}), Point({{2., 0.}}), 1e-6);
0267   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{4, 2}}), Point({{3., 1.}}), 1e-6);
0268 
0269   // test some upper right-bin edges
0270   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1}}), Point({{1., 1.}}), 1e-6);
0271   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2, 3}}), Point({{2., 3.}}), 1e-6);
0272   CHECK_CLOSE_ABS(g.upperRightBinEdge({{3, 1}}), Point({{3., 1.}}), 1e-6);
0273   CHECK_CLOSE_ABS(g.upperRightBinEdge({{4, 2}}), Point({{4., 2.}}), 1e-6);
0274 
0275   // initialize grid
0276   for (std::size_t bin = 0; bin < g.size(); ++bin) {
0277     g.at(bin) = bin;
0278   }
0279 
0280   // consistency of access
0281   const auto& point = Point({{0.7, 1.3}});
0282   std::size_t globalBin = g.globalBinFromPosition(point);
0283   indices localBins = g.localBinsFromGlobalBin(globalBin);
0284 
0285   BOOST_CHECK_EQUAL(g.atPosition(point), g.at(globalBin));
0286   BOOST_CHECK_EQUAL(g.atPosition(point), g.atLocalBins(localBins));
0287 }
0288 
0289 BOOST_AUTO_TEST_CASE(grid_test_3d_equidistant) {
0290   using Point = std::array<double, 3>;
0291   using indices = std::array<std::size_t, 3>;
0292   Axis a(0.0, 2.0, 2u);
0293   Axis b(0.0, 3.0, 3u);
0294   Axis c(0.0, 2.0, 2u);
0295   Grid g(Type<double>, std::move(a), std::move(b), std::move(c));
0296 
0297   // test general properties
0298   BOOST_CHECK_EQUAL(g.size(), 80u);
0299   BOOST_CHECK_EQUAL(g.numLocalBins().at(0), 2u);
0300   BOOST_CHECK_EQUAL(g.numLocalBins().at(1), 3u);
0301   BOOST_CHECK_EQUAL(g.numLocalBins().at(2), 2u);
0302 
0303   // test grid points
0304   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0, 0}})), 25u);
0305   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0, 1}})), 26u);
0306   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0, 2}})), 27u);
0307   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 1, 0}})), 29u);
0308   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 1, 1}})), 30u);
0309   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 1, 2}})), 31u);
0310   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 2, 0}})), 33u);
0311   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 2, 1}})), 34u);
0312   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 2, 2}})), 35u);
0313   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3, 0}})), 37u);
0314   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3, 1}})), 38u);
0315   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3, 2}})), 39u);
0316   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0, 0}})), 45u);
0317   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0, 1}})), 46u);
0318   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0, 2}})), 47u);
0319   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 1, 0}})), 49u);
0320   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 1, 1}})), 50u);
0321   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 1, 2}})), 51u);
0322   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 2, 0}})), 53u);
0323   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 2, 1}})), 54u);
0324   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 2, 2}})), 55u);
0325   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3, 0}})), 57u);
0326   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3, 1}})), 58u);
0327   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3, 2}})), 59u);
0328   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 0, 0}})), 65u);
0329   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 0, 1}})), 66u);
0330   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 0, 2}})), 67u);
0331   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 1, 0}})), 69u);
0332   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 1, 1}})), 70u);
0333   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 1, 2}})), 71u);
0334   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 2, 0}})), 73u);
0335   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 2, 1}})), 74u);
0336   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 2, 2}})), 75u);
0337   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 3, 0}})), 77u);
0338   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 3, 1}})), 78u);
0339   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, 3, 2}})), 79u);
0340 
0341   // global bin index -> local bin indices
0342   BOOST_CHECK(g.localBinsFromGlobalBin(0) == indices({{0, 0, 0}}));
0343   BOOST_CHECK(g.localBinsFromGlobalBin(1) == indices({{0, 0, 1}}));
0344   BOOST_CHECK(g.localBinsFromGlobalBin(2) == indices({{0, 0, 2}}));
0345   BOOST_CHECK(g.localBinsFromGlobalBin(3) == indices({{0, 0, 3}}));
0346   BOOST_CHECK(g.localBinsFromGlobalBin(4) == indices({{0, 1, 0}}));
0347   BOOST_CHECK(g.localBinsFromGlobalBin(5) == indices({{0, 1, 1}}));
0348   BOOST_CHECK(g.localBinsFromGlobalBin(6) == indices({{0, 1, 2}}));
0349   BOOST_CHECK(g.localBinsFromGlobalBin(7) == indices({{0, 1, 3}}));
0350   BOOST_CHECK(g.localBinsFromGlobalBin(24) == indices({{1, 1, 0}}));
0351   BOOST_CHECK(g.localBinsFromGlobalBin(25) == indices({{1, 1, 1}}));
0352   BOOST_CHECK(g.localBinsFromGlobalBin(26) == indices({{1, 1, 2}}));
0353   BOOST_CHECK(g.localBinsFromGlobalBin(27) == indices({{1, 1, 3}}));
0354   BOOST_CHECK(g.localBinsFromGlobalBin(52) == indices({{2, 3, 0}}));
0355   BOOST_CHECK(g.localBinsFromGlobalBin(53) == indices({{2, 3, 1}}));
0356   BOOST_CHECK(g.localBinsFromGlobalBin(54) == indices({{2, 3, 2}}));
0357   BOOST_CHECK(g.localBinsFromGlobalBin(55) == indices({{2, 3, 3}}));
0358   BOOST_CHECK(g.localBinsFromGlobalBin(60) == indices({{3, 0, 0}}));
0359   BOOST_CHECK(g.localBinsFromGlobalBin(61) == indices({{3, 0, 1}}));
0360   BOOST_CHECK(g.localBinsFromGlobalBin(62) == indices({{3, 0, 2}}));
0361   BOOST_CHECK(g.localBinsFromGlobalBin(63) == indices({{3, 0, 3}}));
0362   BOOST_CHECK(g.localBinsFromGlobalBin(76) == indices({{3, 4, 0}}));
0363   BOOST_CHECK(g.localBinsFromGlobalBin(77) == indices({{3, 4, 1}}));
0364   BOOST_CHECK(g.localBinsFromGlobalBin(78) == indices({{3, 4, 2}}));
0365   BOOST_CHECK(g.localBinsFromGlobalBin(79) == indices({{3, 4, 3}}));
0366 
0367   // local bin indices -> global bin index
0368   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0, 0}}), 0u);
0369   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0, 1}}), 1u);
0370   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0, 2}}), 2u);
0371   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0, 3}}), 3u);
0372   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1, 0}}), 4u);
0373   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1, 1}}), 5u);
0374   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1, 2}}), 6u);
0375   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1, 3}}), 7u);
0376   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1, 0}}), 24u);
0377   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1, 1}}), 25u);
0378   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1, 2}}), 26u);
0379   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1, 3}}), 27u);
0380   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3, 0}}), 52u);
0381   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3, 1}}), 53u);
0382   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3, 2}}), 54u);
0383   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3, 3}}), 55u);
0384   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 0, 0}}), 60u);
0385   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 0, 1}}), 61u);
0386   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 0, 2}}), 62u);
0387   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 0, 3}}), 63u);
0388   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 4, 0}}), 76u);
0389   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 4, 1}}), 77u);
0390   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 4, 2}}), 78u);
0391   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 4, 3}}), 79u);
0392 
0393   BOOST_CHECK(g.localBinsFromGlobalBin(g.globalBinFromPosition(
0394                   Point({{1.2, 0.7, 1.4}}))) == indices({{2, 1, 2}}));
0395 
0396   // inside checks
0397   BOOST_CHECK(!g.isInside(Point({{-2., -1, -2}})));
0398   BOOST_CHECK(!g.isInside(Point({{-2., 1., 0.}})));
0399   BOOST_CHECK(!g.isInside(Point({{-2., 5., -1}})));
0400   BOOST_CHECK(!g.isInside(Point({{1., -1., 1.}})));
0401   BOOST_CHECK(!g.isInside(Point({{6., -1., 4.}})));
0402   BOOST_CHECK(g.isInside(Point({{0.5, 1.3, 1.7}})));
0403   BOOST_CHECK(!g.isInside(Point({{2., -1., -0.4}})));
0404   BOOST_CHECK(!g.isInside(Point({{2., 0.3, 3.4}})));
0405   BOOST_CHECK(!g.isInside(Point({{2., 3., 0.8}})));
0406   BOOST_CHECK(!g.isInside(Point({{-1., 3., 5.}})));
0407   BOOST_CHECK(!g.isInside(Point({{2., 3., -1.}})));
0408   BOOST_CHECK(!g.isInside(Point({{5., 3., 0.5}})));
0409 
0410   // test some bin centers
0411   CHECK_CLOSE_ABS(g.binCenter({{1, 1, 1}}), Point({{0.5, 0.5, 0.5}}), 1e-6);
0412   CHECK_CLOSE_ABS(g.binCenter({{2, 3, 2}}), Point({{1.5, 2.5, 1.5}}), 1e-6);
0413   CHECK_CLOSE_ABS(g.binCenter({{1, 1, 2}}), Point({{0.5, 0.5, 1.5}}), 1e-6);
0414   CHECK_CLOSE_ABS(g.binCenter({{2, 2, 1}}), Point({{1.5, 1.5, 0.5}}), 1e-6);
0415 
0416   // test some lower-left bin edges
0417   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1, 1}}), Point({{0., 0., 0.}}), 1e-6);
0418   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2, 3, 2}}), Point({{1., 2., 1.}}), 1e-6);
0419   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1, 2}}), Point({{0., 0., 1.}}), 1e-6);
0420   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2, 2, 1}}), Point({{1., 1., 0.}}), 1e-6);
0421 
0422   // test some upper right-bin edges
0423   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1, 1}}), Point({{1., 1., 1.}}),
0424                   1e-6);
0425   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2, 3, 2}}), Point({{2., 3., 2.}}),
0426                   1e-6);
0427   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1, 2}}), Point({{1., 1., 2.}}),
0428                   1e-6);
0429   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2, 2, 1}}), Point({{2., 2., 1.}}),
0430                   1e-6);
0431 
0432   // initialize grid
0433   for (std::size_t bin = 0; bin < g.size(); ++bin) {
0434     g.at(bin) = bin;
0435   }
0436 
0437   // consistency of access
0438   const auto& point = Point({{0.7, 2.3, 1.3}});
0439   std::size_t globalBin = g.globalBinFromPosition(point);
0440   indices localBins = g.localBinsFromGlobalBin(globalBin);
0441 
0442   BOOST_CHECK_EQUAL(g.atPosition(point), g.at(globalBin));
0443   BOOST_CHECK_EQUAL(g.atPosition(point), g.atLocalBins(localBins));
0444 }
0445 
0446 BOOST_AUTO_TEST_CASE(grid_test_1d_variable) {
0447   using Point = std::array<double, 1>;
0448   using indices = std::array<std::size_t, 1>;
0449   Axis a({0.0, 1.0, 4.0});
0450   Grid g(Type<double>, std::move(a));
0451 
0452   // test general properties
0453   BOOST_CHECK_EQUAL(g.size(), 4u);
0454   BOOST_CHECK_EQUAL(g.numLocalBins().at(0), 2u);
0455 
0456   // global bin index
0457   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-0.3}})), 0u);
0458   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.}})), 1u);
0459   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.7}})), 1u);
0460   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1}})), 2u);
0461   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1.2}})), 2u);
0462   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2.7}})), 2u);
0463   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4.}})), 3u);
0464   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{4.98}})), 3u);
0465 
0466   // global bin index -> local bin indices
0467   BOOST_CHECK(g.localBinsFromGlobalBin(0) == indices({{0}}));
0468   BOOST_CHECK(g.localBinsFromGlobalBin(1) == indices({{1}}));
0469   BOOST_CHECK(g.localBinsFromGlobalBin(2) == indices({{2}}));
0470   BOOST_CHECK(g.localBinsFromGlobalBin(3) == indices({{3}}));
0471 
0472   // local bin indices -> global bin index
0473   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0}}), 0u);
0474   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1}}), 1u);
0475   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2}}), 2u);
0476   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3}}), 3u);
0477 
0478   BOOST_CHECK(g.localBinsFromGlobalBin(
0479                   g.globalBinFromPosition(Point({{0.8}}))) == indices({{1}}));
0480 
0481   // inside checks
0482   BOOST_CHECK(!g.isInside(Point({{-2.}})));
0483   BOOST_CHECK(g.isInside(Point({{0.}})));
0484   BOOST_CHECK(g.isInside(Point({{2.5}})));
0485   BOOST_CHECK(!g.isInside(Point({{4.}})));
0486   BOOST_CHECK(!g.isInside(Point({{6.}})));
0487 
0488   // test some bin centers
0489   CHECK_CLOSE_ABS(g.binCenter({{1}}), Point({{0.5}}), 1e-6);
0490   CHECK_CLOSE_ABS(g.binCenter({{2}}), Point({{2.5}}), 1e-6);
0491 
0492   // test some lower-left bin edges
0493   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1}}), Point({{0.}}), 1e-6);
0494   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2}}), Point({{1.}}), 1e-6);
0495 
0496   // test some upper right-bin edges
0497   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1}}), Point({{1.}}), 1e-6);
0498   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2}}), Point({{4.}}), 1e-6);
0499 
0500   // initialize grid
0501   for (std::size_t bin = 0; bin < g.size(); ++bin) {
0502     g.at(bin) = bin;
0503   }
0504 
0505   // consistency of access
0506   const auto& point = Point({{0.7}});
0507   std::size_t globalBin = g.globalBinFromPosition(point);
0508   indices localBins = g.localBinsFromGlobalBin(globalBin);
0509 
0510   BOOST_CHECK_EQUAL(g.atPosition(point), g.at(globalBin));
0511   BOOST_CHECK_EQUAL(g.atPosition(point), g.atLocalBins(localBins));
0512 }
0513 
0514 BOOST_AUTO_TEST_CASE(grid_test_2d_variable) {
0515   using Point = std::array<double, 2>;
0516   using indices = std::array<std::size_t, 2>;
0517   Axis a({0.0, 0.5, 3.0});
0518   Axis b({0.0, 1.0, 4.0});
0519   Grid g(Type<double>, std::move(a), std::move(b));
0520 
0521   // test general properties
0522   BOOST_CHECK_EQUAL(g.size(), 16u);
0523   BOOST_CHECK_EQUAL(g.numLocalBins().at(0), 2u);
0524   BOOST_CHECK_EQUAL(g.numLocalBins().at(1), 2u);
0525 
0526   // test grid points
0527   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0}})), 5u);
0528   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 1}})), 6u);
0529   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 4}})), 7u);
0530   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.5, 0}})), 9u);
0531   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.5, 1}})), 10u);
0532   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.5, 4}})), 11u);
0533   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 0}})), 13u);
0534   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 1}})), 14u);
0535   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3, 4}})), 15u);
0536 
0537   // test some arbitrary points
0538   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.3, 1.2}})), 6u);
0539   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3.3, 2.2}})), 14u);
0540   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1.8, 0.9}})), 9u);
0541   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{3.1, 0.7}})), 13u);
0542   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2.3, 1.4}})), 10u);
0543   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{2, -3}})), 8u);
0544   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 8}})), 11u);
0545   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-3, 1}})), 2u);
0546   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{11, 3}})), 14u);
0547   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-3, -2}})), 0u);
0548   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{7, -2}})), 12u);
0549   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-1, 12}})), 3u);
0550   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{11, 12}})), 15u);
0551 
0552   // global bin index -> local bin indices
0553   BOOST_CHECK(g.localBinsFromGlobalBin(0) == indices({{0, 0}}));
0554   BOOST_CHECK(g.localBinsFromGlobalBin(1) == indices({{0, 1}}));
0555   BOOST_CHECK(g.localBinsFromGlobalBin(2) == indices({{0, 2}}));
0556   BOOST_CHECK(g.localBinsFromGlobalBin(3) == indices({{0, 3}}));
0557   BOOST_CHECK(g.localBinsFromGlobalBin(4) == indices({{1, 0}}));
0558   BOOST_CHECK(g.localBinsFromGlobalBin(5) == indices({{1, 1}}));
0559   BOOST_CHECK(g.localBinsFromGlobalBin(6) == indices({{1, 2}}));
0560   BOOST_CHECK(g.localBinsFromGlobalBin(7) == indices({{1, 3}}));
0561   BOOST_CHECK(g.localBinsFromGlobalBin(8) == indices({{2, 0}}));
0562   BOOST_CHECK(g.localBinsFromGlobalBin(9) == indices({{2, 1}}));
0563   BOOST_CHECK(g.localBinsFromGlobalBin(10) == indices({{2, 2}}));
0564   BOOST_CHECK(g.localBinsFromGlobalBin(11) == indices({{2, 3}}));
0565   BOOST_CHECK(g.localBinsFromGlobalBin(12) == indices({{3, 0}}));
0566   BOOST_CHECK(g.localBinsFromGlobalBin(13) == indices({{3, 1}}));
0567   BOOST_CHECK(g.localBinsFromGlobalBin(14) == indices({{3, 2}}));
0568   BOOST_CHECK(g.localBinsFromGlobalBin(15) == indices({{3, 3}}));
0569 
0570   // local bin indices -> global bin index
0571   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0}}), 0u);
0572   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1}}), 1u);
0573   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 2}}), 2u);
0574   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 3}}), 3u);
0575   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 0}}), 4u);
0576   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1}}), 5u);
0577   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 2}}), 6u);
0578   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 3}}), 7u);
0579   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 0}}), 8u);
0580   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 1}}), 9u);
0581   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 2}}), 10u);
0582   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3}}), 11u);
0583   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 0}}), 12u);
0584   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 1}}), 13u);
0585   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 2}}), 14u);
0586   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 3}}), 15u);
0587 
0588   BOOST_CHECK(g.localBinsFromGlobalBin(g.globalBinFromPosition(
0589                   Point({{3.2, 1.8}}))) == indices({{3, 2}}));
0590 
0591   // inside checks
0592   BOOST_CHECK(!g.isInside(Point({{-2., -1}})));
0593   BOOST_CHECK(!g.isInside(Point({{-2., 1.}})));
0594   BOOST_CHECK(!g.isInside(Point({{-2., 5.}})));
0595   BOOST_CHECK(!g.isInside(Point({{1., -1.}})));
0596   BOOST_CHECK(!g.isInside(Point({{6., -1.}})));
0597   BOOST_CHECK(g.isInside(Point({{0.5, 1.3}})));
0598   BOOST_CHECK(!g.isInside(Point({{3., -1.}})));
0599   BOOST_CHECK(!g.isInside(Point({{3., 0.3}})));
0600   BOOST_CHECK(!g.isInside(Point({{3., 4.}})));
0601   BOOST_CHECK(!g.isInside(Point({{-1., 4.}})));
0602   BOOST_CHECK(!g.isInside(Point({{2., 4.}})));
0603   BOOST_CHECK(!g.isInside(Point({{5., 4.}})));
0604 
0605   // test some bin centers
0606   CHECK_CLOSE_ABS(g.binCenter({{1, 1}}), Point({{0.25, 0.5}}), 1e-6);
0607   CHECK_CLOSE_ABS(g.binCenter({{2, 1}}), Point({{1.75, 0.5}}), 1e-6);
0608   CHECK_CLOSE_ABS(g.binCenter({{1, 2}}), Point({{0.25, 2.5}}), 1e-6);
0609   CHECK_CLOSE_ABS(g.binCenter({{2, 2}}), Point({{1.75, 2.5}}), 1e-6);
0610 
0611   // test some lower-left bin edges
0612   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1}}), Point({{0., 0.}}), 1e-6);
0613   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2, 1}}), Point({{0.5, 0.}}), 1e-6);
0614   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 2}}), Point({{0., 1.}}), 1e-6);
0615   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2, 2}}), Point({{0.5, 1.}}), 1e-6);
0616 
0617   // test some upper right-bin edges
0618   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1}}), Point({{0.5, 1.}}), 1e-6);
0619   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2, 1}}), Point({{3., 1.}}), 1e-6);
0620   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 2}}), Point({{0.5, 4.}}), 1e-6);
0621   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2, 2}}), Point({{3., 4.}}), 1e-6);
0622 
0623   // initialize grid
0624   for (std::size_t bin = 0; bin < g.size(); ++bin) {
0625     g.at(bin) = bin;
0626   }
0627 
0628   // consistency of access
0629   const auto& point = Point({{0.7, 1.3}});
0630   std::size_t globalBin = g.globalBinFromPosition(point);
0631   indices localBins = g.localBinsFromGlobalBin(globalBin);
0632 
0633   BOOST_CHECK_EQUAL(g.atPosition(point), g.at(globalBin));
0634   BOOST_CHECK_EQUAL(g.atPosition(point), g.atLocalBins(localBins));
0635 }
0636 
0637 BOOST_AUTO_TEST_CASE(grid_test_3d_variable) {
0638   using Point = std::array<double, 3>;
0639   using indices = std::array<std::size_t, 3>;
0640   Axis a({0.0, 1.0});
0641   Axis b({0.0, 0.5, 3.0});
0642   Axis c({0.0, 0.5, 3.0, 3.3});
0643   Grid g(Type<double>, std::move(a), std::move(b), std::move(c));
0644 
0645   // test general properties
0646   BOOST_CHECK_EQUAL(g.size(), 60u);
0647   BOOST_CHECK_EQUAL(g.numLocalBins().at(0), 1u);
0648   BOOST_CHECK_EQUAL(g.numLocalBins().at(1), 2u);
0649   BOOST_CHECK_EQUAL(g.numLocalBins().at(2), 3u);
0650 
0651   // test grid points
0652   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0, 0}})), 26u);
0653   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0, 0}})), 46u);
0654   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0.5, 0}})), 31u);
0655   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0.5, 0}})), 51u);
0656   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3, 0}})), 36u);
0657   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3, 0}})), 56u);
0658   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0, 0.5}})), 27u);
0659   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0, 0.5}})), 47u);
0660   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0.5, 0.5}})), 32u);
0661   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0.5, 0.5}})), 52u);
0662   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3, 0.5}})), 37u);
0663   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3, 0.5}})), 57u);
0664   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0, 3}})), 28u);
0665   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0, 3}})), 48u);
0666   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0.5, 3}})), 33u);
0667   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0.5, 3}})), 53u);
0668   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3, 3}})), 38u);
0669   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3, 3}})), 58u);
0670   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0, 3.3}})), 29u);
0671   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0, 3.3}})), 49u);
0672   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0.5, 3.3}})), 34u);
0673   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0.5, 3.3}})), 54u);
0674   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3, 3.3}})), 39u);
0675   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3, 3.3}})), 59u);
0676 
0677   // global bin index -> local bin indices
0678   BOOST_CHECK(g.localBinsFromGlobalBin(0) == indices({{0, 0, 0}}));
0679   BOOST_CHECK(g.localBinsFromGlobalBin(1) == indices({{0, 0, 1}}));
0680   BOOST_CHECK(g.localBinsFromGlobalBin(2) == indices({{0, 0, 2}}));
0681   BOOST_CHECK(g.localBinsFromGlobalBin(3) == indices({{0, 0, 3}}));
0682   BOOST_CHECK(g.localBinsFromGlobalBin(4) == indices({{0, 0, 4}}));
0683   BOOST_CHECK(g.localBinsFromGlobalBin(5) == indices({{0, 1, 0}}));
0684   BOOST_CHECK(g.localBinsFromGlobalBin(21) == indices({{1, 0, 1}}));
0685   BOOST_CHECK(g.localBinsFromGlobalBin(22) == indices({{1, 0, 2}}));
0686   BOOST_CHECK(g.localBinsFromGlobalBin(23) == indices({{1, 0, 3}}));
0687   BOOST_CHECK(g.localBinsFromGlobalBin(24) == indices({{1, 0, 4}}));
0688   BOOST_CHECK(g.localBinsFromGlobalBin(25) == indices({{1, 1, 0}}));
0689   BOOST_CHECK(g.localBinsFromGlobalBin(26) == indices({{1, 1, 1}}));
0690   BOOST_CHECK(g.localBinsFromGlobalBin(57) == indices({{2, 3, 2}}));
0691   BOOST_CHECK(g.localBinsFromGlobalBin(58) == indices({{2, 3, 3}}));
0692   BOOST_CHECK(g.localBinsFromGlobalBin(59) == indices({{2, 3, 4}}));
0693 
0694   // local bin indices -> global bin index
0695   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0, 0}}), 0u);
0696   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 0, 0}}), 20u);
0697   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 0, 0}}), 40u);
0698   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1, 0}}), 5u);
0699   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1, 0}}), 25u);
0700   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 1, 0}}), 45u);
0701   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 3, 1}}), 16u);
0702   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 3, 1}}), 36u);
0703   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3, 1}}), 56u);
0704   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0, 2}}), 2u);
0705   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 0, 2}}), 22u);
0706   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 0, 2}}), 42u);
0707   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 3, 4}}), 19u);
0708   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 3, 4}}), 39u);
0709   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3, 4}}), 59u);
0710 
0711   BOOST_CHECK(g.localBinsFromGlobalBin(g.globalBinFromPosition(
0712                   Point({{1.8, 0.7, 3.2}}))) == indices({{2, 2, 3}}));
0713 
0714   // inside checks
0715   BOOST_CHECK(!g.isInside(Point({{-2., -1, -2}})));
0716   BOOST_CHECK(!g.isInside(Point({{-2., 1., 0.}})));
0717   BOOST_CHECK(!g.isInside(Point({{-2., 5., -1}})));
0718   BOOST_CHECK(!g.isInside(Point({{1., -1., 1.}})));
0719   BOOST_CHECK(!g.isInside(Point({{6., -1., 4.}})));
0720   BOOST_CHECK(g.isInside(Point({{0.5, 1.3, 1.7}})));
0721   BOOST_CHECK(!g.isInside(Point({{1., -1., -0.4}})));
0722   BOOST_CHECK(!g.isInside(Point({{1., 0.3, 3.4}})));
0723   BOOST_CHECK(!g.isInside(Point({{1., 3., 0.8}})));
0724   BOOST_CHECK(!g.isInside(Point({{-1., 3., 5.}})));
0725   BOOST_CHECK(!g.isInside(Point({{2., 3., -1.}})));
0726   BOOST_CHECK(!g.isInside(Point({{5., 3., 0.5}})));
0727 
0728   // test some bin centers
0729   CHECK_CLOSE_ABS(g.binCenter({{1, 1, 1}}), Point({{0.5, 0.25, 0.25}}), 1e-6);
0730   CHECK_CLOSE_ABS(g.binCenter({{1, 1, 2}}), Point({{0.5, 0.25, 1.75}}), 1e-6);
0731   CHECK_CLOSE_ABS(g.binCenter({{1, 1, 3}}), Point({{0.5, 0.25, 3.15}}), 1e-6);
0732   CHECK_CLOSE_ABS(g.binCenter({{1, 2, 1}}), Point({{0.5, 1.75, 0.25}}), 1e-6);
0733   CHECK_CLOSE_ABS(g.binCenter({{1, 2, 2}}), Point({{0.5, 1.75, 1.75}}), 1e-6);
0734   CHECK_CLOSE_ABS(g.binCenter({{1, 2, 3}}), Point({{0.5, 1.75, 3.15}}), 1e-6);
0735 
0736   // test some lower-left bin edges
0737   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1, 1}}), Point({{0., 0., 0.}}), 1e-6);
0738   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1, 2}}), Point({{0., 0., 0.5}}),
0739                   1e-6);
0740   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1, 3}}), Point({{0., 0., 3.}}), 1e-6);
0741   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 2, 1}}), Point({{0., 0.5, 0.}}),
0742                   1e-6);
0743   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 2, 2}}), Point({{0., 0.5, 0.5}}),
0744                   1e-6);
0745   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 2, 3}}), Point({{0., 0.5, 3.}}),
0746                   1e-6);
0747 
0748   // test some upper right-bin edges
0749   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1, 1}}), Point({{1., 0.5, 0.5}}),
0750                   1e-6);
0751   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1, 2}}), Point({{1., 0.5, 3.}}),
0752                   1e-6);
0753   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1, 3}}), Point({{1., 0.5, 3.3}}),
0754                   1e-6);
0755   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 2, 1}}), Point({{1., 3., 0.5}}),
0756                   1e-6);
0757   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 2, 2}}), Point({{1., 3., 3.}}),
0758                   1e-6);
0759   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 2, 3}}), Point({{1., 3., 3.3}}),
0760                   1e-6);
0761 
0762   // initialize grid
0763   for (std::size_t bin = 0; bin < g.size(); ++bin) {
0764     g.at(bin) = bin;
0765   }
0766 
0767   // consistency of access
0768   const auto& point = Point({{0.7, 1.3, 3.7}});
0769   std::size_t globalBin = g.globalBinFromPosition(point);
0770   indices localBins = g.localBinsFromGlobalBin(globalBin);
0771 
0772   BOOST_CHECK_EQUAL(g.atPosition(point), g.at(globalBin));
0773   BOOST_CHECK_EQUAL(g.atPosition(point), g.atLocalBins(localBins));
0774 }
0775 
0776 BOOST_AUTO_TEST_CASE(grid_test_2d_mixed) {
0777   using Point = std::array<double, 2>;
0778   using indices = std::array<std::size_t, 2>;
0779   Axis a(0.0, 1.0, 4u);
0780   Axis b({0.0, 0.5, 3.0});
0781   Grid g(Type<double>, std::move(a), std::move(b));
0782 
0783   // test general properties
0784   BOOST_CHECK_EQUAL(g.size(), 24u);
0785   BOOST_CHECK_EQUAL(g.numLocalBins().at(0), 4u);
0786   BOOST_CHECK_EQUAL(g.numLocalBins().at(1), 2u);
0787 
0788   // test grid points
0789   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0}})), 5u);
0790   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.25, 0}})), 9u);
0791   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.5, 0}})), 13u);
0792   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.75, 0}})), 17u);
0793   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0}})), 21u);
0794   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 0.5}})), 6u);
0795   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.25, 0.5}})), 10u);
0796   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.5, 0.5}})), 14u);
0797   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.75, 0.5}})), 18u);
0798   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 0.5}})), 22u);
0799   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0, 3}})), 7u);
0800   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.25, 3}})), 11u);
0801   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.5, 3}})), 15u);
0802   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.75, 3}})), 19u);
0803   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1, 3}})), 23u);
0804 
0805   // test some arbitrary points
0806   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{1.2, 0.3}})), 21u);
0807   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.2, 1.3}})), 6u);
0808   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.9, 1.8}})), 18u);
0809   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.7, 2.1}})), 14u);
0810   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.4, 0.3}})), 9u);
0811   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-3, 2}})), 2u);
0812   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{8, 1}})), 22u);
0813   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.1, -3}})), 4u);
0814   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{0.8, 11}})), 19u);
0815   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-2, -3}})), 0u);
0816   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{-2, 7}})), 3u);
0817   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{12, -1}})), 20u);
0818   BOOST_CHECK_EQUAL(g.globalBinFromPosition(Point({{12, 11}})), 23u);
0819 
0820   // global bin index -> local bin indices
0821   using indices = std::array<std::size_t, 2>;
0822   BOOST_CHECK(g.localBinsFromGlobalBin(0) == indices({{0, 0}}));
0823   BOOST_CHECK(g.localBinsFromGlobalBin(1) == indices({{0, 1}}));
0824   BOOST_CHECK(g.localBinsFromGlobalBin(2) == indices({{0, 2}}));
0825   BOOST_CHECK(g.localBinsFromGlobalBin(3) == indices({{0, 3}}));
0826   BOOST_CHECK(g.localBinsFromGlobalBin(4) == indices({{1, 0}}));
0827   BOOST_CHECK(g.localBinsFromGlobalBin(5) == indices({{1, 1}}));
0828   BOOST_CHECK(g.localBinsFromGlobalBin(6) == indices({{1, 2}}));
0829   BOOST_CHECK(g.localBinsFromGlobalBin(7) == indices({{1, 3}}));
0830   BOOST_CHECK(g.localBinsFromGlobalBin(8) == indices({{2, 0}}));
0831   BOOST_CHECK(g.localBinsFromGlobalBin(9) == indices({{2, 1}}));
0832   BOOST_CHECK(g.localBinsFromGlobalBin(10) == indices({{2, 2}}));
0833   BOOST_CHECK(g.localBinsFromGlobalBin(11) == indices({{2, 3}}));
0834   BOOST_CHECK(g.localBinsFromGlobalBin(12) == indices({{3, 0}}));
0835   BOOST_CHECK(g.localBinsFromGlobalBin(13) == indices({{3, 1}}));
0836   BOOST_CHECK(g.localBinsFromGlobalBin(14) == indices({{3, 2}}));
0837   BOOST_CHECK(g.localBinsFromGlobalBin(15) == indices({{3, 3}}));
0838   BOOST_CHECK(g.localBinsFromGlobalBin(16) == indices({{4, 0}}));
0839   BOOST_CHECK(g.localBinsFromGlobalBin(17) == indices({{4, 1}}));
0840   BOOST_CHECK(g.localBinsFromGlobalBin(18) == indices({{4, 2}}));
0841   BOOST_CHECK(g.localBinsFromGlobalBin(19) == indices({{4, 3}}));
0842   BOOST_CHECK(g.localBinsFromGlobalBin(20) == indices({{5, 0}}));
0843   BOOST_CHECK(g.localBinsFromGlobalBin(21) == indices({{5, 1}}));
0844   BOOST_CHECK(g.localBinsFromGlobalBin(22) == indices({{5, 2}}));
0845   BOOST_CHECK(g.localBinsFromGlobalBin(23) == indices({{5, 3}}));
0846 
0847   // local bin indices -> global bin index
0848   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 0}}), 0u);
0849   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 1}}), 1u);
0850   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 2}}), 2u);
0851   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{0, 3}}), 3u);
0852   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 0}}), 4u);
0853   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 1}}), 5u);
0854   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 2}}), 6u);
0855   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{1, 3}}), 7u);
0856   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 0}}), 8u);
0857   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 1}}), 9u);
0858   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 2}}), 10u);
0859   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{2, 3}}), 11u);
0860   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 0}}), 12u);
0861   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 1}}), 13u);
0862   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 2}}), 14u);
0863   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{3, 3}}), 15u);
0864   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 0}}), 16u);
0865   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 1}}), 17u);
0866   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 2}}), 18u);
0867   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{4, 3}}), 19u);
0868   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 0}}), 20u);
0869   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 1}}), 21u);
0870   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 2}}), 22u);
0871   BOOST_CHECK_EQUAL(g.globalBinFromLocalBins({{5, 3}}), 23u);
0872 
0873   BOOST_CHECK(g.localBinsFromGlobalBin(g.globalBinFromPosition(
0874                   Point({{1.1, 1.7}}))) == indices({{5, 2}}));
0875 
0876   // inside checks
0877   BOOST_CHECK(!g.isInside(Point({{-2., -1}})));
0878   BOOST_CHECK(!g.isInside(Point({{-2., 1.}})));
0879   BOOST_CHECK(!g.isInside(Point({{-2., 5.}})));
0880   BOOST_CHECK(!g.isInside(Point({{0.1, -1.}})));
0881   BOOST_CHECK(!g.isInside(Point({{6., -1.}})));
0882   BOOST_CHECK(g.isInside(Point({{0.5, 1.3}})));
0883   BOOST_CHECK(!g.isInside(Point({{1., -1.}})));
0884   BOOST_CHECK(!g.isInside(Point({{1., 0.3}})));
0885   BOOST_CHECK(!g.isInside(Point({{1., 3.}})));
0886   BOOST_CHECK(!g.isInside(Point({{-1., 3.}})));
0887   BOOST_CHECK(!g.isInside(Point({{0.2, 3.}})));
0888   BOOST_CHECK(!g.isInside(Point({{5., 3.}})));
0889 
0890   // test some bin centers
0891   CHECK_CLOSE_ABS(g.binCenter({{1, 1}}), Point({{0.125, 0.25}}), 1e-6);
0892   CHECK_CLOSE_ABS(g.binCenter({{1, 2}}), Point({{0.125, 1.75}}), 1e-6);
0893   CHECK_CLOSE_ABS(g.binCenter({{2, 1}}), Point({{0.375, 0.25}}), 1e-6);
0894   CHECK_CLOSE_ABS(g.binCenter({{2, 2}}), Point({{0.375, 1.75}}), 1e-6);
0895   CHECK_CLOSE_ABS(g.binCenter({{3, 1}}), Point({{0.625, 0.25}}), 1e-6);
0896   CHECK_CLOSE_ABS(g.binCenter({{3, 2}}), Point({{0.625, 1.75}}), 1e-6);
0897   CHECK_CLOSE_ABS(g.binCenter({{4, 1}}), Point({{0.875, 0.25}}), 1e-6);
0898   CHECK_CLOSE_ABS(g.binCenter({{4, 2}}), Point({{0.875, 1.75}}), 1e-6);
0899 
0900   // test some lower-left bin edges
0901   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 1}}), Point({{0., 0.}}), 1e-6);
0902   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{1, 2}}), Point({{0., 0.5}}), 1e-6);
0903   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2, 1}}), Point({{0.25, 0.}}), 1e-6);
0904   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{2, 2}}), Point({{0.25, 0.5}}), 1e-6);
0905   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{3, 1}}), Point({{0.5, 0.}}), 1e-6);
0906   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{3, 2}}), Point({{0.5, 0.5}}), 1e-6);
0907   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{4, 1}}), Point({{0.75, 0.}}), 1e-6);
0908   CHECK_CLOSE_ABS(g.lowerLeftBinEdge({{4, 2}}), Point({{0.75, 0.5}}), 1e-6);
0909 
0910   // test some upper-right bin edges
0911   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 1}}), Point({{0.25, 0.5}}), 1e-6);
0912   CHECK_CLOSE_ABS(g.upperRightBinEdge({{1, 2}}), Point({{0.25, 3.}}), 1e-6);
0913   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2, 1}}), Point({{0.5, 0.5}}), 1e-6);
0914   CHECK_CLOSE_ABS(g.upperRightBinEdge({{2, 2}}), Point({{0.5, 3.}}), 1e-6);
0915   CHECK_CLOSE_ABS(g.upperRightBinEdge({{3, 1}}), Point({{0.75, 0.5}}), 1e-6);
0916   CHECK_CLOSE_ABS(g.upperRightBinEdge({{3, 2}}), Point({{0.75, 3.}}), 1e-6);
0917   CHECK_CLOSE_ABS(g.upperRightBinEdge({{4, 1}}), Point({{1., 0.5}}), 1e-6);
0918   CHECK_CLOSE_ABS(g.upperRightBinEdge({{4, 2}}), Point({{1., 3.}}), 1e-6);
0919 
0920   // initialize grid
0921   for (std::size_t bin = 0; bin < g.size(); ++bin) {
0922     g.at(bin) = bin;
0923   }
0924 
0925   // consistency of access
0926   const auto& point = Point({{1.3, 3.7}});
0927   std::size_t globalBin = g.globalBinFromPosition(point);
0928   indices localBins = g.localBinsFromGlobalBin(globalBin);
0929 
0930   BOOST_CHECK_EQUAL(g.atPosition(point), g.at(globalBin));
0931   BOOST_CHECK_EQUAL(g.atPosition(point), g.atLocalBins(localBins));
0932 }
0933 
0934 BOOST_AUTO_TEST_CASE(grid_test_2d_mixed_at) {
0935   Axis a(0.0, 6.0, 4u);
0936   Axis b({0.0, 1.5, 3.0});
0937   Grid g(Type<double>, std::move(a), std::move(b));
0938 
0939   // initialize the grid
0940   using Point = std::array<double, 2>;
0941   g.atPosition(Point({{0, 0}})) = 0.;
0942   g.atPosition(Point({{1.5, 0}})) = 1.;
0943   g.atPosition(Point({{3, 0}})) = 2.;
0944   g.atPosition(Point({{4.5, 0}})) = 3.;
0945   g.atPosition(Point({{6, 0}})) = 4.;
0946   g.atPosition(Point({{0, 1.5}})) = 5.;
0947   g.atPosition(Point({{1.5, 1.5}})) = 6.;
0948   g.atPosition(Point({{3, 1.5}})) = 7.;
0949   g.atPosition(Point({{4.5, 1.5}})) = 8.;
0950   g.atPosition(Point({{6, 1.5}})) = 9.;
0951   g.atPosition(Point({{0, 3}})) = 10.;
0952   g.atPosition(Point({{1.5, 3}})) = 11.;
0953   g.atPosition(Point({{3, 3}})) = 12.;
0954   g.atPosition(Point({{4.5, 3}})) = 13.;
0955   g.atPosition(Point({{6, 3}})) = 14.;
0956 
0957   // test general properties
0958   BOOST_CHECK_EQUAL(g.size(), 24u);
0959 
0960   // test some arbitrary points
0961   BOOST_CHECK_EQUAL(g.atPosition(Point({{1.2, 0.3}})), 0.);
0962   BOOST_CHECK_EQUAL(g.atPosition(Point({{2.2, 1.3}})), 1.);
0963   BOOST_CHECK_EQUAL(g.atPosition(Point({{4.9, 1.8}})), 8.);
0964   BOOST_CHECK_EQUAL(g.atPosition(Point({{3.7, 2.1}})), 7.);
0965   BOOST_CHECK_EQUAL(g.atPosition(Point({{0.4, 2.3}})), 5.);
0966 }
0967 
0968 BOOST_AUTO_TEST_CASE(grid_interpolation) {
0969   using Point = std::array<double, 3>;
0970   Axis a(1.0, 3.0, 2u);
0971   Axis b(1.0, 5.0, 2u);
0972   Axis c(1.0, 7.0, 2u);
0973   Grid g(Type<double>, std::move(a), std::move(b), std::move(c));
0974 
0975   g.atPosition(Point({{1., 1., 1.}})) = 10.;
0976   g.atPosition(Point({{2., 1., 1.}})) = 20.;
0977   g.atPosition(Point({{1., 3., 1.}})) = 30.;
0978   g.atPosition(Point({{2., 3., 1.}})) = 40.;
0979   g.atPosition(Point({{1., 1., 4.}})) = 50.;
0980   g.atPosition(Point({{2., 1., 4.}})) = 60.;
0981   g.atPosition(Point({{1., 3., 4.}})) = 70.;
0982   g.atPosition(Point({{2., 3., 4.}})) = 80.;
0983 
0984   CHECK_CLOSE_REL(g.interpolate(Point({{1., 1., 1.}})), 10., 1e-6);
0985   CHECK_CLOSE_REL(g.interpolate(Point({{2., 1., 1.}})), 20., 1e-6);
0986   CHECK_CLOSE_REL(g.interpolate(Point({{1., 3., 1.}})), 30., 1e-6);
0987   CHECK_CLOSE_REL(g.interpolate(Point({{2., 3., 1.}})), 40., 1e-6);
0988   CHECK_CLOSE_REL(g.interpolate(Point({{1., 1., 4.}})), 50., 1e-6);
0989   CHECK_CLOSE_REL(g.interpolate(Point({{2., 1., 4.}})), 60., 1e-6);
0990   CHECK_CLOSE_REL(g.interpolate(Point({{1., 3., 4.}})), 70., 1e-6);
0991   CHECK_CLOSE_REL(g.interpolate(Point({{2., 3., 4.}})), 80., 1e-6);
0992   CHECK_CLOSE_REL(g.interpolate(Point({{1.5, 1., 1.}})), 15., 1e-6);
0993   CHECK_CLOSE_REL(g.interpolate(Point({{1.5, 3., 1.}})), 35., 1e-6);
0994   CHECK_CLOSE_REL(g.interpolate(Point({{1., 2., 1.}})), 20., 1e-6);
0995   CHECK_CLOSE_REL(g.interpolate(Point({{2., 2., 1.}})), 30., 1e-6);
0996   CHECK_CLOSE_REL(g.interpolate(Point({{1.5, 1., 4.}})), 55., 1e-6);
0997   CHECK_CLOSE_REL(g.interpolate(Point({{1.5, 3., 4.}})), 75., 1e-6);
0998   CHECK_CLOSE_REL(g.interpolate(Point({{1., 2., 4.}})), 60., 1e-6);
0999   CHECK_CLOSE_REL(g.interpolate(Point({{2., 2., 4.}})), 70., 1e-6);
1000   CHECK_CLOSE_REL(g.interpolate(Point({{1., 1., 2.5}})), 30., 1e-6);
1001   CHECK_CLOSE_REL(g.interpolate(Point({{1., 3., 2.5}})), 50., 1e-6);
1002   CHECK_CLOSE_REL(g.interpolate(Point({{2., 1., 2.5}})), 40., 1e-6);
1003   CHECK_CLOSE_REL(g.interpolate(Point({{2., 3., 2.5}})), 60., 1e-6);
1004   CHECK_CLOSE_REL(g.interpolate(Point({{1.5, 2., 2.5}})), 360. / 8, 1e-6);
1005   CHECK_CLOSE_REL(g.interpolate(Point({{1.3, 2.1, 1.6}})), 32., 1e-6);
1006   CHECK_CLOSE_REL(g.interpolate(Point({{2., 3., 4.}})), 80., 1e-6);
1007 }
1008 
1009 BOOST_AUTO_TEST_CASE(neighborhood) {
1010   using bins_t = std::vector<std::size_t>;
1011 
1012   Axis a(0.0, 1.0, 10u);
1013   Axis b(0.0, 1.0, 10u);
1014   Axis c(0.0, 1.0, 10u);
1015   Grid g1(Type<double>, Axis{a});
1016   Grid g2(Type<double>, Axis{a}, Axis{b});
1017   Grid g3(Type<double>, std::move(a), std::move(b), std::move(c));
1018 
1019   // clang-format off
1020     // 1D case
1021     BOOST_CHECK(g1.neighborHoodIndices({{0}}, 1).collectVector()
1022                 == bins_t({0, 1}));
1023     BOOST_CHECK(g1.neighborHoodIndices({{0}}, 2).collectVector()
1024                 == bins_t({0, 1, 2}));
1025     BOOST_CHECK(g1.neighborHoodIndices({{1}}, 1).collectVector()
1026                 == bins_t({0, 1, 2}));
1027     BOOST_CHECK(g1.neighborHoodIndices({{1}}, 3).collectVector()
1028                 == bins_t({0, 1, 2, 3, 4}));
1029     BOOST_CHECK(g1.neighborHoodIndices({{4}}, 2).collectVector()
1030                 == bins_t({2, 3, 4, 5, 6}));
1031     BOOST_CHECK(g1.neighborHoodIndices({{9}}, 2).collectVector()
1032                 == bins_t({7, 8, 9, 10, 11}));
1033     BOOST_CHECK(g1.neighborHoodIndices({{10}}, 2).collectVector()
1034                 == bins_t({8, 9, 10, 11}));
1035     BOOST_CHECK(g1.neighborHoodIndices({{11}}, 2).collectVector()
1036                 == bins_t({9, 10, 11}));
1037 
1038     // 2D case
1039     BOOST_CHECK(g2.neighborHoodIndices({{0, 0}}, 1).collectVector()
1040                 == bins_t({0, 1, 12, 13}));
1041     BOOST_CHECK(g2.neighborHoodIndices({{0, 1}}, 1).collectVector()
1042                 == bins_t({0, 1, 2, 12, 13, 14}));
1043     BOOST_CHECK(g2.neighborHoodIndices({{1, 0}}, 1).collectVector()
1044                 == bins_t({0, 1, 12, 13, 24, 25}));
1045     BOOST_CHECK(g2.neighborHoodIndices({{1, 1}}, 1).collectVector()
1046                 == bins_t({0, 1, 2, 12, 13, 14, 24, 25, 26}));
1047     BOOST_CHECK(g2.neighborHoodIndices({{5, 5}}, 1).collectVector()
1048                 == bins_t({52, 53, 54, 64, 65, 66, 76, 77, 78}));
1049     BOOST_CHECK(g2.neighborHoodIndices({{9, 10}}, 2).collectVector()
1050                 == bins_t({92, 93, 94, 95, 104, 105, 106, 107, 116, 117, 118,
1051                            119, 128, 129, 130, 131, 140, 141, 142, 143}));
1052 
1053     // 3D case
1054     BOOST_CHECK(g3.neighborHoodIndices({{0, 0, 0}}, 1).collectVector()
1055                 == bins_t({0, 1, 12, 13, 144, 145, 156, 157}));
1056     BOOST_CHECK(g3.neighborHoodIndices({{0, 0, 1}}, 1).collectVector()
1057                 == bins_t({0, 1, 2, 12, 13, 14, 144, 145, 146, 156, 157, 158}));
1058     BOOST_CHECK(g3.neighborHoodIndices({{0, 1, 0}}, 1).collectVector()
1059                 == bins_t({0, 1, 12, 13, 24, 25, 144, 145, 156, 157, 168, 169}));
1060     BOOST_CHECK(g3.neighborHoodIndices({{1, 0, 0}}, 1).collectVector()
1061                 == bins_t({0, 1, 12, 13, 144, 145, 156, 157, 288, 289, 300, 301}));
1062     BOOST_CHECK(g3.neighborHoodIndices({{0, 1, 1}}, 1).collectVector()
1063                 == bins_t({0, 1, 2, 12, 13, 14, 24, 25, 26, 144, 145, 146,
1064                            156, 157, 158, 168, 169, 170}));
1065     BOOST_CHECK(g3.neighborHoodIndices({{1, 1, 1}}, 1).collectVector()
1066                 == bins_t({0, 1, 2, 12, 13, 14, 24, 25, 26, 144, 145, 146,
1067                            156, 157, 158, 168, 169, 170, 288, 289, 290, 300,
1068                            301, 302, 312, 313, 314}));
1069     BOOST_CHECK(g3.neighborHoodIndices({{11, 10, 9}}, 1).collectVector()
1070                 == bins_t({1556, 1557, 1558, 1568, 1569, 1570, 1580, 1581,
1071                            1582, 1700, 1701, 1702, 1712, 1713, 1714, 1724,
1072                            1725, 1726}));
1073 
1074     // Neighbors array
1075     std::array<std::pair<int,int>,1> a1;
1076     a1.at(0) = std::make_pair<int,int>(-1,1);
1077     BOOST_CHECK(g1.neighborHoodIndices({{0}}, a1).collectVector()
1078                 == bins_t({0,1}));
1079     BOOST_CHECK(g1.neighborHoodIndices({{2}}, a1).collectVector()
1080                 == bins_t({1,2,3}));
1081 
1082     a1.at(0) = std::make_pair<int,int>(2,3);
1083     BOOST_CHECK(g1.neighborHoodIndices({{2}}, a1).collectVector()
1084                 == bins_t({4,5}));
1085 
1086     a1.at(0) = std::make_pair<int,int>(-2,-1);
1087     BOOST_CHECK(g1.neighborHoodIndices({{2}}, a1).collectVector()
1088                 == bins_t({0,1}));
1089 
1090     a1.at(0) = std::make_pair<int,int>(-3,-1);
1091     BOOST_CHECK(g1.neighborHoodIndices({{2}}, a1).collectVector()
1092                 == bins_t({0,1}));
1093   // clang-format on
1094 
1095   Axis d(AxisClosed, 0.0, 1.0, 10u);
1096 
1097   Grid g1Cl(Type<double>, std::move(d));
1098   BOOST_CHECK(g1Cl.neighborHoodIndices({{0}}, 1).collectVector() ==
1099               bins_t({}));  // underflow, makes no sense
1100   BOOST_CHECK(g1Cl.neighborHoodIndices({{11}}, 1).collectVector() ==
1101               bins_t({}));  // overflow, makes no sense
1102   BOOST_CHECK(g1Cl.neighborHoodIndices({{1}}, 1).collectVector() ==
1103               bins_t({10, 1, 2}));  // overflow, makes no sense
1104   BOOST_CHECK(g1Cl.neighborHoodIndices({{5}}, 1).collectVector() ==
1105               bins_t({4, 5, 6}));  // overflow, makes no sense
1106 
1107   Axis f(AxisClosed, 0.0, 1.0, 5u);
1108   Axis e(AxisClosed, 0.0, 1.0, 5u);
1109   Grid g2Cl(Type<double>, std::move(e), std::move(f));
1110   BOOST_CHECK(g2Cl.neighborHoodIndices({{3, 3}}, 1).collectVector() ==
1111               bins_t({16, 17, 18, 23, 24, 25, 30, 31, 32}));
1112   BOOST_CHECK(g2Cl.neighborHoodIndices({{1, 1}}, 1).collectVector() ==
1113               bins_t({40, 36, 37, 12, 8, 9, 19, 15, 16}));
1114   BOOST_CHECK(g2Cl.neighborHoodIndices({{1, 5}}, 1).collectVector() ==
1115               bins_t({39, 40, 36, 11, 12, 8, 18, 19, 15}));
1116   BOOST_CHECK(g2Cl.neighborHoodIndices({{5, 1}}, 1).collectVector() ==
1117               bins_t({33, 29, 30, 40, 36, 37, 12, 8, 9}));
1118   BOOST_CHECK(g2Cl.neighborHoodIndices({{5, 5}}, 1).collectVector() ==
1119               bins_t({32, 33, 29, 39, 40, 36, 11, 12, 8}));
1120 
1121   BOOST_CHECK(g2Cl.neighborHoodIndices({{3, 3}}, 2).collectVector() ==
1122               bins_t({8,  9,  10, 11, 12, 15, 16, 17, 18, 19, 22, 23, 24,
1123                       25, 26, 29, 30, 31, 32, 33, 36, 37, 38, 39, 40}));
1124   BOOST_CHECK(g2Cl.neighborHoodIndices({{1, 1}}, 2).collectVector() ==
1125               bins_t({32, 33, 29, 30, 31, 39, 40, 36, 37, 38, 11, 12, 8,
1126                       9,  10, 18, 19, 15, 16, 17, 25, 26, 22, 23, 24}));
1127   BOOST_CHECK(g2Cl.neighborHoodIndices({{1, 5}}, 2).collectVector() ==
1128               bins_t({31, 32, 33, 29, 30, 38, 39, 40, 36, 37, 10, 11, 12,
1129                       8,  9,  17, 18, 19, 15, 16, 24, 25, 26, 22, 23}));
1130   BOOST_CHECK(g2Cl.neighborHoodIndices({{5, 1}}, 2).collectVector() ==
1131               bins_t({25, 26, 22, 23, 24, 32, 33, 29, 30, 31, 39, 40, 36,
1132                       37, 38, 11, 12, 8,  9,  10, 18, 19, 15, 16, 17}));
1133   BOOST_CHECK(g2Cl.neighborHoodIndices({{5, 5}}, 2).collectVector() ==
1134               bins_t({24, 25, 26, 22, 23, 31, 32, 33, 29, 30, 38, 39, 40,
1135                       36, 37, 10, 11, 12, 8,  9,  17, 18, 19, 15, 16}));
1136 
1137   std::array<std::pair<int, int>, 2> a2;
1138   a2.at(0) =
1139       std::make_pair<int, int>(-2, -1);  // only 2 bins left of requested bin
1140                                          // (not including the requested bin)
1141   a2.at(1) = std::make_pair<int, int>(
1142       -1, 2);  // one bin left of requested bin, the requested bin itself and 2
1143                // bins right of requested bin
1144   std::set<std::size_t> returnedBins;
1145 
1146   auto returnedBinsVec = g2Cl.neighborHoodIndices({{3, 2}}, a2).collectVector();
1147   returnedBins.insert(returnedBinsVec.begin(), returnedBinsVec.end());
1148   std::set<std::size_t> expectedBins{{8, 9, 10, 11, 15, 16, 17, 18}};
1149   BOOST_CHECK(returnedBins == expectedBins);
1150 
1151   returnedBinsVec = g2Cl.neighborHoodIndices({{1, 5}}, a2).collectVector();
1152   returnedBins.clear();
1153   returnedBins.insert(returnedBinsVec.begin(), returnedBinsVec.end());
1154   expectedBins = {{29, 30, 32, 33, 36, 37, 39, 40}};
1155   BOOST_CHECK(returnedBins == expectedBins);
1156 
1157   a2.at(0) = {-6, 7};
1158   a2.at(1) = {0, 0};
1159   returnedBinsVec = g2Cl.neighborHoodIndices({{1, 5}}, a2).collectVector();
1160   returnedBins.clear();
1161   returnedBins.insert(returnedBinsVec.begin(), returnedBinsVec.end());
1162   expectedBins = {{12, 19, 26, 33, 40}};
1163   BOOST_CHECK(returnedBins == expectedBins);
1164 
1165   // @TODO 3D test would be nice, but should essentially not be a problem if
1166   // 2D works.
1167 
1168   // clang-format off
1169     /*
1170      *       1   2    3    4    5
1171      *   |------------------------|
1172      * 1 |  8 |  9 | 10 | 11 | 12 |
1173      *   |----|----|----|----|----|
1174      * 2 | 15 | 16 | 17 | 18 | 19 |
1175      *   |----|----|----|----|----|
1176      * 3 | 22 | 23 | 24 | 25 | 26 |
1177      *   |----|----|----|----|----|
1178      * 4 | 29 | 30 | 31 | 32 | 33 |
1179      *   |----|----|----|----|----|
1180      * 5 | 36 | 37 | 38 | 39 | 40 |
1181      *   |------------------------|
1182      */
1183   // clang-format on
1184 }
1185 
1186 BOOST_AUTO_TEST_CASE(closestPoints) {
1187   using Point = std::array<double, 3>;
1188   using bins_t = std::vector<std::size_t>;
1189 
1190   Axis a(0.0, 1.0, 10u);
1191   Axis b(0.0, 1.0, 5u);
1192   Axis c(0.0, 1.0, 3u);
1193   Grid g1(Type<double>, Axis{a});
1194   Grid g2(Type<double>, Axis{a}, Axis{b});
1195   Grid g3(Type<double>, std::move(a), std::move(b), std::move(c));
1196 
1197   // clang-format off
1198     // 1D case
1199     BOOST_CHECK(g1.closestPointsIndices(Point({{0.52}})).collectVector()
1200                 == bins_t({6, 7}));
1201     BOOST_CHECK(g1.closestPointsIndices(Point({{0.98}})).collectVector()
1202                 == bins_t({10, 11}));
1203 
1204     // 2D case
1205     BOOST_CHECK(g2.closestPointsIndices(Point({{0.52, 0.08}})).collectVector()
1206                 == bins_t({43, 44, 50, 51}));
1207     BOOST_CHECK(g2.closestPointsIndices(Point({{0.05, 0.08}})).collectVector()
1208                 == bins_t({8, 9, 15, 16}));
1209 
1210     // 3D case
1211     BOOST_CHECK(g3.closestPointsIndices(Point({{0.23, 0.13, 0.61}})).collectVector()
1212                 == bins_t({112, 113, 117, 118, 147, 148, 152, 153}));
1213     BOOST_CHECK(g3.closestPointsIndices(Point({{0.52, 0.35, 0.71}})).collectVector()
1214                 == bins_t({223, 224, 228, 229, 258, 259, 263, 264}));
1215 
1216     using EAxisClosed = Axis<AxisType::Equidistant, AxisBoundaryType::Closed>;
1217     using Grid1Cl_t = Grid<double, EAxisClosed>;
1218     using Grid2Cl_t = Grid<double, EAxisClosed, EAxisClosed>;
1219     //using Grid3Cl_t = Grid<double, EAxisClosed, EAxisClosed, EAxisClosed>;
1220     EAxisClosed   aCl(0.0, 1.0, 10u);
1221     EAxisClosed   bCl(0.0, 1.0, 5u);
1222     // EAxisClosed   cCl(0.0, 1.0, 3u);
1223     Grid1Cl_t g1Cl(std::make_tuple(aCl));
1224     Grid2Cl_t g2Cl(std::make_tuple(std::move(aCl), std::move(bCl)));
1225 
1226     // 1D case
1227     BOOST_CHECK(g1Cl.closestPointsIndices(Point({{0.52}})).collectVector()
1228                 == bins_t({6, 7}));
1229     BOOST_CHECK(g1Cl.closestPointsIndices(Point({{0.98}})).collectVector()
1230                 == bins_t({10, 1}));
1231 
1232     // 2D case
1233     BOOST_CHECK(g2Cl.closestPointsIndices(Point({{0.52, 0.08}})).collectVector()
1234                 == bins_t({43, 44, 50, 51}));
1235     BOOST_CHECK(g2Cl.closestPointsIndices(Point({{0.52, 0.68}})).collectVector()
1236                 == bins_t({46, 47, 53, 54}));
1237     BOOST_CHECK(g2Cl.closestPointsIndices(Point({{0.52, 0.88}})).collectVector()
1238                 == bins_t({47, 43, 54, 50}));
1239     BOOST_CHECK(g2Cl.closestPointsIndices(Point({{0.05, 0.08}})).collectVector()
1240                 == bins_t({8, 9, 15, 16}));
1241     BOOST_CHECK(g2Cl.closestPointsIndices(Point({{0.9, 0.95}})).collectVector()
1242                 == bins_t({75, 71, 12, 8}));
1243 
1244     // @TODO: 3D checks would also be nice
1245 
1246     Axis  aOp(AxisBound,0.0, 1.0, 10u);
1247     Axis  bOp(AxisBound,0.0, 1.0, 5u);
1248     Grid g1Op(Type<double>, Axis{aOp});
1249     Grid g2Op(Type<double>, std::move(aOp), std::move(bOp));
1250 
1251     // 1D case
1252     BOOST_CHECK(g1Op.closestPointsIndices(Point({{0.52}})).collectVector()
1253                 == bins_t({6, 7}));
1254     BOOST_CHECK(g1Op.closestPointsIndices(Point({{0.98}})).collectVector()
1255                 == bins_t({10}));
1256     BOOST_CHECK(g1Op.closestPointsIndices(Point({{0.88}})).collectVector()
1257                 == bins_t({9, 10}));
1258 
1259     // 2D case
1260     BOOST_CHECK(g2Op.closestPointsIndices(Point({{0.52, 0.08}})).collectVector()
1261                 == bins_t({43, 44, 50, 51}));
1262     BOOST_CHECK(g2Op.closestPointsIndices(Point({{0.52, 0.68}})).collectVector()
1263                 == bins_t({46, 47, 53, 54}));
1264     BOOST_CHECK(g2Op.closestPointsIndices(Point({{0.52, 0.88}})).collectVector()
1265                 == bins_t({47, 54}));
1266     BOOST_CHECK(g2Op.closestPointsIndices(Point({{0.05, 0.1}})).collectVector()
1267                 == bins_t({8, 9, 15, 16}));
1268     BOOST_CHECK(g2Op.closestPointsIndices(Point({{0.95, 0.95}})).collectVector()
1269                 == bins_t({75}));
1270 
1271     // @TODO: 3D checks would also be nice
1272 
1273     /*
1274      *       1    2    3    4    5
1275      *    |------------------------|
1276      *  1 |  8 |  9 | 10 | 11 | 12 |
1277      *    |----|----|----|----|----|
1278      *  2 | 15 | 16 | 17 | 18 | 19 |
1279      *    |----|----|----|----|----|
1280      *  3 | 22 | 23 | 24 | 25 | 26 |
1281      *    |----|----|----|----|----|
1282      *  4 | 29 | 30 | 31 | 32 | 33 |
1283      *    |----|----|----|----|----|
1284      *  5 | 36 | 37 | 38 | 39 | 40 |
1285      *    |------------------------|
1286      *  6 | 43 | 44 | 45 | 46 | 47 |
1287      *    |------------------------|
1288      *  7 | 50 | 51 | 52 | 53 | 54 |
1289      *    |------------------------|
1290      *  8 | 57 | 58 | 59 | 60 | 61 |
1291      *    |------------------------|
1292      *  9 | 64 | 65 | 66 | 67 | 68 |
1293      *    |------------------------|
1294      * 10 | 71 | 72 | 73 | 74 | 75 |
1295      *    |------------------------|
1296      * 77   78   79   80   81   82   83
1297      */
1298 
1299   // clang-format on
1300 }
1301 
1302 BOOST_AUTO_TEST_CASE(grid_type_conversion) {
1303   // Type conversion test
1304   using Grid2Int =
1305       Grid<int, Axis<AxisType::Equidistant>, Axis<AxisType::Variable>>;
1306 
1307   Axis a(0.0, 1.0, 10u);
1308   Axis b({0., 1.2, 2.3, 3.4, 4.5, 5.6});
1309   Grid g2(Type<double>, std::move(a), std::move(b));
1310   decltype(g2) g2Copy(g2.axesTuple());
1311 
1312   static_assert(std::same_as<decltype(g2), decltype(g2Copy)>);
1313 
1314   auto g2ConvertedInt = g2Copy.convertType<int>();
1315   static_assert(std::same_as<decltype(g2ConvertedInt), Grid2Int>);
1316 }
1317 
1318 BOOST_AUTO_TEST_CASE(grid_full_conversion) {
1319   // The converter class
1320   struct DoubleToInt {
1321     // Declare a value tupe
1322     using value_type = int;
1323     // the conversion operator
1324     int operator()(double d) { return static_cast<int>(d); }
1325   };
1326 
1327   // Grid conversion test
1328   Axis a(0.0, 1.0, 2u);
1329   Grid g1(Type<double>, std::move(a));
1330 
1331   using Point = std::array<double, 1>;
1332   g1.atPosition(Point({{0.3}})) = 1.1;
1333   g1.atPosition(Point({{0.6}})) = 2.4;
1334 
1335   DoubleToInt d2i;
1336 
1337   auto g1ConvertedInt = g1.convertGrid(d2i);
1338   BOOST_CHECK_EQUAL(g1ConvertedInt.atPosition(Point({{0.3}})), 1);
1339   BOOST_CHECK_EQUAL(g1ConvertedInt.atPosition(Point({{0.6}})), 2);
1340 }
1341 
1342 BOOST_AUTO_TEST_CASE(Output) {
1343   Axis a{AxisOpen, 0.0, 1.0, 10u};
1344   Axis b{AxisBound, {1, 2, 3}};
1345 
1346   Grid g(Type<double>, std::move(a), std::move(b));
1347 
1348   std::stringstream ss;
1349   ss << g;
1350   BOOST_CHECK_EQUAL(
1351       ss.str(),
1352       "Axis<Equidistant, Open>(0, 1, 10), Axis<Variable, Bound>(1, 2, 3)");
1353 
1354   const IGrid& ig = g;
1355 
1356   ss.str("");
1357 
1358   ss << ig;
1359 
1360   BOOST_CHECK_EQUAL(
1361       ss.str(),
1362       "Axis<Equidistant, Open>(0, 1, 10), Axis<Variable, Bound>(1, 2, 3)");
1363 }
1364 
1365 BOOST_AUTO_TEST_CASE(Equality) {
1366   Axis a{AxisOpen, 0.0, 1.0, 10u};
1367   Axis b{AxisBound, {1, 2, 3}};
1368   Axis c{AxisClosed, {1, 2, 5}};
1369 
1370   Grid ab{Type<double>, a, b};
1371   Grid ac{Type<double>, a, c};
1372 
1373   BOOST_CHECK_EQUAL(ab, ab);
1374   BOOST_CHECK_EQUAL(ac, ac);
1375   BOOST_CHECK_NE(ab, ac);
1376 
1377   const IGrid& iab = ab;
1378   const IGrid& iac = ac;
1379 
1380   BOOST_CHECK_EQUAL(iab, iab);
1381   BOOST_CHECK_EQUAL(iac, iac);
1382 }
1383 
1384 BOOST_AUTO_TEST_SUITE_END()
1385 
1386 }  // namespace ActsTests
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!