Core/Detector/KdtSurfacesProviderTests.cpp

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/Detector/KdtSurfacesProvider.hpp"
0013 #include "Acts/Geometry/Extent.hpp"
0014 #include "Acts/Geometry/GeometryContext.hpp"
0015 #include "Acts/Geometry/LayerCreator.hpp"
0016 #include "Acts/Surfaces/Surface.hpp"
0017 #include "Acts/Tests/CommonHelpers/CylindricalTrackingGeometry.hpp"
0018 #include "Acts/Utilities/BinningType.hpp"
0019 #include "Acts/Utilities/Enumerate.hpp"
0020 #include "Acts/Utilities/GridAxisGenerators.hpp"
0021
0022 #include <algorithm>
0023 #include <cstddef>
0024 #include <iterator>
0025 #include <memory>
0026 #include <utility>
0027 #include <vector>
0028
0029 using namespace Acts;
0030 using namespace Acts::Test;
0031 using namespace Acts::Experimental;
0032
0033 GeometryContext tContext;
0034 CylindricalTrackingGeometry cGeometry = CylindricalTrackingGeometry(tContext);
0035
0036 namespace {
0037 /// Helper method that allows to use the already existing testing
0038 /// infrastructure with the new const-correct detector design
0039 ///
0040 std::vector<std::shared_ptr<Acts::Surface>> unpackSurfaces(
0041     const std::vector<Acts::Surface*>& surfaces) {
0042   std::vector<std::shared_ptr<Acts::Surface>> uSurfaces;
0043   uSurfaces.reserve(surfaces.size());
0044   for (auto* s : surfaces) {
0045     uSurfaces.push_back(s->getSharedPtr());
0046   }
0047   return uSurfaces;
0048 }
0049
0050 std::vector<std::shared_ptr<Acts::Surface>> pixelSurfaces(
0051     CylindricalTrackingGeometry::DetectorStore& dStore) {
0052   // The surfaces for the KDTree structure
0053   std::vector<std::shared_ptr<Acts::Surface>> pixelSurfaces;
0054   // Fill Discs
0055   std::vector<double> pixelDiscs = {-800., -700., -600., 600., 700., 800.};
0056   for (const auto& z : pixelDiscs) {
0057     auto rSurfaces = cGeometry.surfacesRing(dStore, 6.4, 12.4, 36., 0.125, 0.,
0058                                             55., z, 2., 22u);
0059     auto urSurfaces = unpackSurfaces(rSurfaces);
0060     pixelSurfaces.insert(pixelSurfaces.end(), urSurfaces.begin(),
0061                          urSurfaces.end());
0062   }
0063   // Fill Barrels
0064   std::vector<double> pixelBarrels = {32., 72., 116., 172.};
0065   std::vector<std::pair<int, int>> pixelBinning = {
0066       {16, 14}, {32, 14}, {52, 14}, {78, 14}};
0067   for (auto [ir, r] : enumerate(pixelBarrels)) {
0068     auto cSurfaces = cGeometry.surfacesCylinder(dStore, 8.4, 36., 0.15, 0.145,
0069                                                 r, 3., 2., pixelBinning[ir]);
0070
0071     auto ucSurfaces = unpackSurfaces(cSurfaces);
0072     pixelSurfaces.insert(pixelSurfaces.end(), ucSurfaces.begin(),
0073                          ucSurfaces.end());
0074   }
0075   return pixelSurfaces;
0076 }
0077
0078 }  // namespace
0079
0080 BOOST_AUTO_TEST_SUITE(Detector)
0081
0082 // Test only the KDT infrastructure
0083 BOOST_AUTO_TEST_CASE(KdtSurfacesProvider_misconfigured) {
0084   Acts::Extent region;
0085   BOOST_CHECK_THROW(
0086       Acts::Experimental::KdtSurfacesProvider<> end3(nullptr, region),
0087       std::invalid_argument);
0088 }
0089
0090 // Test only the KDT infrastructure
0091 BOOST_AUTO_TEST_CASE(KdtSurfacesProvider) {
0092   // Detector store
0093   CylindricalTrackingGeometry::DetectorStore dStore;
0094   auto pSurfaces = pixelSurfaces(dStore);
0095   // Count the number of surfacees
0096   std::size_t refNumber = 6u * 22u + 14u * (16u + 32u + 52u + 78u);
0097   BOOST_CHECK_EQUAL(pSurfaces.size(), refNumber);
0098
0099   using KDTS = Acts::Experimental::KdtSurfaces<>;
0100   auto skdt = std::make_shared<KDTS>(
0101       KDTS(tContext, pSurfaces, {AxisDirection::AxisZ, AxisDirection::AxisR}));
0102
0103   // query: Negative disc 3, it should yield 22 surfaces
0104   Acts::Extent regionND3;
0105   regionND3.set(AxisDirection::AxisZ, -820, -780);
0106   regionND3.set(AxisDirection::AxisR, 0., 200.);
0107   Acts::Experimental::KdtSurfacesProvider<> end3(skdt, regionND3);
0108
0109   auto nd3 = end3.surfaces(tContext);
0110   BOOST_CHECK_EQUAL(nd3.size(), 22u);
0111
0112   // query: 2nd Pixel barrel
0113   Acts::Extent regionB1;
0114   regionB1.set(AxisDirection::AxisZ, -580, 580);
0115   regionB1.set(AxisDirection::AxisR, 60., 80.);
0116
0117   Acts::Experimental::KdtSurfacesProvider<> ba1(skdt, regionB1);
0118
0119   auto b1 = ba1.surfaces(tContext);
0120   refNumber = 32u * 14u;
0121   BOOST_CHECK_EQUAL(b1.size(), refNumber);
0122 }
0123
0124 BOOST_AUTO_TEST_SUITE_END()