EIC code displayed by LXR master/​acts/​Tests/​UnitTests/​Core/​Navigation/​NavigationStateUpdatersTests.cpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-11-30 09:22:59

 // This file is part of the ACTS project.
 //
 // Copyright (C) 2016 CERN for the benefit of the ACTS project
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 #include <boost/test/unit_test.hpp>
 
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Navigation/NavigationState.hpp"
 #include "Acts/Navigation/NavigationStateFillers.hpp"
 #include "Acts/Navigation/NavigationStateUpdaters.hpp"
 #include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/IAxis.hpp"
 
 #include <algorithm>
 #include <array>
 #include <cstddef>
 #include <memory>
 #include <tuple>
 #include <utility>
 #include <vector>
 
 #include "../Surfaces/SurfaceStub.hpp"
 
 // A test context
 Acts::GeometryContext tContext;
 
 namespace Acts {
 
 namespace Experimental {
 
 class Detector;
 
 /// A detector volume
 class DetectorVolume {
  public:
   const Detector* d = nullptr;
   std::vector<const Surface*> sfs = {};
   std::vector<const Portal*> prts = {};
   const std::vector<const Surface*> surfaces() const { return sfs; }
   const std::vector<const Portal*> portals() const { return prts; }
   const Detector* detector() const { return d; };
 };
 
 /// A detector
 class Detector {
  public:
   std::vector<const DetectorVolume*> vs = {};
   const std::vector<const DetectorVolume*> volumes() const { return vs; }
 };
 
 /// Helper extractors: all surfaces
 struct AllPortalsExtractor {
   /// Extract the surfaces from the volume
   ///
   /// @param gctx the geometry contextfor this extraction call
   /// @param nState is the navigation state for the extraction
   /// @param indices is an ignored index vector
   inline static const std::vector<const Portal*> extract(
       [[maybe_unused]] const GeometryContext& gctx,
       const NavigationState& nState,
       [[maybe_unused]] const std::vector<std::size_t>& indices = {}) {
     return nState.currentVolume->portals();
   }
 };
 
 /// Helper extractors: all surfaces
 struct AllSurfacesExtractor {
   /// Extract the surfaces from the volume
   ///
   /// @param gctx the geometry contextfor this extraction call
   /// @param nState is the navigation state for the extraction
   /// @param indices is an ignored index vector
   inline static const std::vector<const Surface*> extract(
       [[maybe_unused]] const GeometryContext& gctx,
       const NavigationState& nState,
       [[maybe_unused]] const std::vector<std::size_t>& indices = {}) {
     return nState.currentVolume->surfaces();
   }
 };
 
 /// Helper extractors: indexed surfaces
 struct IndexedSurfacesExtractor {
   /// Extract the surfaces from the volume
   ///
   /// @param gctx the geometry contextfor this extraction call
   /// @param nState is the navigation state for the extraction
   /// @param indices are access indices into the surfaces store
   inline static const std::vector<const Surface*> extract(
       [[maybe_unused]] const GeometryContext& gctx,
       const NavigationState& nState, const std::vector<std::size_t>& indices) {
     // Get the surface container
     const auto& surfaces = nState.currentVolume->surfaces();
     // The extracted surfaces
     std::vector<const Surface*> eSurfaces;
     eSurfaces.reserve(indices.size());
     std::ranges::for_each(
         indices, [&](const auto& i) { eSurfaces.push_back(surfaces[i]); });
     return eSurfaces;
   }
 };
 
 }  // namespace Experimental
 
 class TestAxis : public IAxis {
  public:
   TestAxis() = default;
 
   bool isEquidistant() const final { return true; }
 
   bool isVariable() const final { return false; }
 
   AxisType getType() const final { return AxisType::Equidistant; }
 
   AxisBoundaryType getBoundaryType() const final {
     return AxisBoundaryType::Closed;
   }
 
   std::vector<double> getBinEdges() const final { return {-1, 1}; }
 
   double getMin() const final { return -1.; }
 
   double getMax() const final { return 1.; }
 
   std::size_t getNBins() const final { return 1; };
 
   void toStream(std::ostream& os) const final { os << "TextAxis"; }
 };
 
 class MultiGrid1D {
  public:
   static constexpr std::size_t DIM = 1u;
   using point_t = std::array<double, DIM>;
 
   const std::vector<std::size_t>& atPosition(
       const std::array<double, 1u>& /*position*/) const {
     return e;
   }
 
   std::array<const IAxis*, DIM> axes() const { return {&ta}; }
   TestAxis ta = TestAxis();
 
  private:
   std::vector<std::size_t> e = {0u, 1u};
 };
 
 class MultiGrid2D {
  public:
   static constexpr std::size_t DIM = 2u;
   using point_t = std::array<double, DIM>;
 
   const std::vector<std::size_t>& atPosition(
       const std::array<double, 2u>& /*position*/) const {
     return e;
   }
 
   std::array<const IAxis*, DIM> axes() const { return {&ta, &ta}; };
   TestAxis ta = TestAxis();
 
  private:
   std::vector<std::size_t> e = {1u};
 };
 }  // namespace Acts
 
 using namespace Acts;
 
 namespace ActsTests {
 
 using SingleVolumeUpdater =
     Experimental::SingleObjectNavigation<Experimental::IExternalNavigation,
                                          Experimental::DetectorVolume,
                                          Experimental::DetectorVolumeFiller>;
 
 using AllSurfacesProvider =
     Experimental::StaticAccessNavigation<Experimental::IInternalNavigation,
                                          Experimental::AllSurfacesExtractor,
                                          Experimental::SurfacesFiller>;
 
 using AllPortalsProvider =
     Experimental::StaticAccessNavigation<Experimental::IInternalNavigation,
                                          Experimental::AllPortalsExtractor,
                                          Experimental::PortalsFiller>;
 
 auto surfaceA = Surface::makeShared<SurfaceStub>();
 auto surfaceB = Surface::makeShared<SurfaceStub>();
 auto surfaceC = Surface::makeShared<SurfaceStub>();
 
 auto pSurfaceA = Surface::makeShared<SurfaceStub>();
 auto pSurfaceB = Surface::makeShared<SurfaceStub>();
 auto portalA = std::make_shared<Experimental::Portal>(pSurfaceA);
 auto portalB = std::make_shared<Experimental::Portal>(pSurfaceB);
 
 BOOST_AUTO_TEST_SUITE(NavigationSuite)
 
 BOOST_AUTO_TEST_CASE(SingleExternalNavigationDelegate) {
   Experimental::NavigationState nState;
 
   // Create a single object and a single object updator
   auto sVolume = std::make_shared<Experimental::DetectorVolume>();
   SingleVolumeUpdater sVolumeUpdater(sVolume.get());
 
   // Update the volume and check that it is indeed updated
   sVolumeUpdater.update(tContext, nState);
   BOOST_CHECK_EQUAL(nState.currentVolume, sVolume.get());
 }
 
 BOOST_AUTO_TEST_CASE(AllSurfaces) {
   // Create a single object and a single object updator
   auto dVolume = std::make_shared<Experimental::DetectorVolume>();
   (*dVolume).sfs = {surfaceA.get(), surfaceB.get(), surfaceC.get()};
   (*dVolume).prts = {portalA.get(), portalB.get()};
 
   Experimental::NavigationState nState;
   nState.currentVolume = dVolume.get();
   BOOST_CHECK(nState.surfaceCandidates.empty());
   AllSurfacesProvider allSurfaces;
   allSurfaces.update(tContext, nState);
   BOOST_CHECK_EQUAL(nState.surfaceCandidates.size(), 3u);
 }
 
 BOOST_AUTO_TEST_CASE(AllPortals) {
   // Create a single object and a single object updator
   auto dVolume = std::make_shared<Experimental::DetectorVolume>();
   (*dVolume).sfs = {surfaceA.get(), surfaceB.get(), surfaceC.get()};
   (*dVolume).prts = {portalA.get(), portalB.get()};
 
   Experimental::NavigationState nState;
   nState.currentVolume = dVolume.get();
   BOOST_CHECK(nState.surfaceCandidates.empty());
   AllPortalsProvider allPortals;
   allPortals.update(tContext, nState);
   BOOST_CHECK_EQUAL(nState.surfaceCandidates.size(), 2u);
 }
 
 BOOST_AUTO_TEST_CASE(AllPortalsAllSurfaces) {
   // Create a single object and a single object updator
   auto dVolume = std::make_shared<Experimental::DetectorVolume>();
   (*dVolume).sfs = {surfaceA.get(), surfaceB.get(), surfaceC.get()};
   (*dVolume).prts = {portalA.get(), portalB.get()};
 
   Experimental::NavigationState nState;
   nState.currentVolume = dVolume.get();
   BOOST_CHECK(nState.surfaceCandidates.empty());
 
   AllPortalsProvider allPortals;
   AllSurfacesProvider allSurfaces;
   auto allPortalsAllSurfaces =
       Experimental::ChainedNavigation<Experimental::IInternalNavigation,
                                       AllPortalsProvider, AllSurfacesProvider>(
           std::tie(allPortals, allSurfaces));
 
   allPortalsAllSurfaces.update(tContext, nState);
   BOOST_CHECK_EQUAL(nState.surfaceCandidates.size(), 5u);
 }
 
 BOOST_AUTO_TEST_CASE(AllPortalsGrid1DSurfaces) {
   // Create a single object and a single object updator
   auto dVolume = std::make_shared<Experimental::DetectorVolume>();
   (*dVolume).sfs = {surfaceA.get(), surfaceB.get(), surfaceC.get()};
   (*dVolume).prts = {portalA.get(), portalB.get()};
 
   Experimental::NavigationState nState;
   nState.currentVolume = dVolume.get();
   BOOST_CHECK(nState.surfaceCandidates.empty());
 
   AllPortalsProvider allPortals;
   MultiGrid1D grid;
   using Grid1DSurfacesProvider = Experimental::IndexedGridNavigation<
       Experimental::IInternalNavigation, decltype(grid),
       Experimental::IndexedSurfacesExtractor, Experimental::SurfacesFiller>;
   auto grid1DSurfaces =
       Grid1DSurfacesProvider(std::move(grid), {AxisDirection::AxisR});
 
   auto allPortalsGrid1DSurfaces =
       Experimental::ChainedNavigation<Experimental::IInternalNavigation,
                                       AllPortalsProvider,
                                       Grid1DSurfacesProvider>(
           std::tie(allPortals, grid1DSurfaces));
 
   allPortalsGrid1DSurfaces.update(tContext, nState);
   BOOST_CHECK_EQUAL(nState.surfaceCandidates.size(), 4u);
 }
 
 BOOST_AUTO_TEST_CASE(AllPortalsGrid2DSurfaces) {
   // Create a single object and a single object updator
   auto dVolume = std::make_shared<Experimental::DetectorVolume>();
   (*dVolume).sfs = {surfaceA.get(), surfaceB.get(), surfaceC.get()};
   (*dVolume).prts = {portalA.get(), portalB.get()};
 
   Experimental::NavigationState nState;
   nState.currentVolume = dVolume.get();
   BOOST_CHECK(nState.surfaceCandidates.empty());
 
   AllPortalsProvider allPortals;
   MultiGrid2D grid;
   using Grid2DSurfacesProvider = Experimental::IndexedGridNavigation<
       Experimental::IInternalNavigation, decltype(grid),
       Experimental::IndexedSurfacesExtractor, Experimental::SurfacesFiller>;
   auto grid2DSurfaces = Grid2DSurfacesProvider(
       std::move(grid), {AxisDirection::AxisR, AxisDirection::AxisZ});
 
   auto allPortalsGrid2DSurfaces =
       Experimental::ChainedNavigation<Experimental::IInternalNavigation,
                                       AllPortalsProvider,
                                       Grid2DSurfacesProvider>(
           std::tie(allPortals, grid2DSurfaces));
 
   allPortalsGrid2DSurfaces.update(tContext, nState);
   BOOST_CHECK_EQUAL(nState.surfaceCandidates.size(), 3u);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
 
 }  // namespace ActsTests

This page was automatically generated by the 2.3.7 LXR engine. The LXR team