Acts/Navigation/MultiLayerSurfacesUpdater.hpp

0001 // This file is part of the Acts project.
0002 //
0003 // Copyright (C) 2022 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 #pragma once
0010
0011 #include "Acts/Detector/DetectorVolume.hpp"
0012 #include "Acts/Navigation/NavigationDelegates.hpp"
0013 #include "Acts/Navigation/NavigationStateFillers.hpp"
0014 #include "Acts/Navigation/NavigationStateUpdaters.hpp"
0015 #include "Acts/Utilities/VectorHelpers.hpp"
0016
0017 #include <array>
0018 #include <memory>
0019
0020 namespace Acts::Experimental {
0021
0022 template <typename grid_t, typename path_generator>
0023 class MultiLayerSurfacesUpdaterImpl : public INavigationDelegate {
0024  public:
0025   /// Broadcast the grid type
0026   using grid_type = grid_t;
0027
0028   /// The grid where the indices are stored
0029   grid_type grid;
0030
0031   /// The path generator
0032   path_generator pgenerator;
0033
0034   /// These are the cast parameters - copied from constructor
0035   std::array<BinningValue, grid_type::DIM> casts{};
0036
0037   /// An inverse transform to be applied to the position
0038   Transform3 transform = Transform3::Identity();
0039
0040   /// @brief  Constructor for a grid based surface attacher
0041   /// @param igrid the grid that is moved into this attacher
0042   /// @param icasts is the cast values array
0043   /// @param itr a transform applied to the global position
0044   MultiLayerSurfacesUpdaterImpl(
0045       grid_type igrid, const std::array<BinningValue, grid_type::DIM>& icasts,
0046       const Transform3& itr = Transform3::Identity())
0047       : grid(std::move(igrid)), casts(icasts), transform(itr) {}
0048
0049   MultiLayerSurfacesUpdaterImpl() = delete;
0050
0051   void update(const GeometryContext& gctx, NavigationState& nState) const {
0052     // get the local position and direction
0053     auto lposition = transform * nState.position;
0054     auto ldirection = transform.linear() * nState.direction;
0055
0056     auto step = std::sqrt(std::pow(grid.binWidth()[0], 2) +
0057                           std::pow(grid.binWidth()[1], 2));
0058     auto path = pgenerator(lposition, ldirection, step, grid.numLocalBins()[1]);
0059
0060     std::vector<const Acts::Surface*> surfCandidates = {};
0061
0062     for (const auto& p : path) {
0063       const auto& entry = grid.atPosition(castPosition(p));
0064       const auto extracted =
0065           IndexedSurfacesExtractor::extract(gctx, nState, entry);
0066       surfCandidates.insert(surfCandidates.end(), extracted.begin(),
0067                             extracted.end());
0068     }
0069
0070     resolveDuplicates(gctx, surfCandidates);
0071     SurfacesFiller::fill(nState, surfCandidates);
0072
0073     updateCandidates(gctx, nState);
0074   }
0075
0076   /// Cast into a lookup position
0077   ///
0078   /// @param position is the position of the update call
0079   std::array<ActsScalar, grid_type::DIM> castPosition(
0080       const Vector3& position) const {
0081     std::array<ActsScalar, grid_type::DIM> casted{};
0082     fillCasts(position, casted,
0083               std::make_integer_sequence<std::size_t, grid_type::DIM>{});
0084     return casted;
0085   }
0086
0087   /// Resolve duplicate on surface candidates
0088   ///
0089   /// @param gctx The geometry context of the current geometry
0090   /// @param surfaces is the surface candidates to check and resolve for duplicates
0091   void resolveDuplicates(const GeometryContext& gctx,
0092                          std::vector<const Acts::Surface*>& surfaces) const {
0093     // sorting the surfaces according to their radial distance
0094     std::sort(surfaces.begin(), surfaces.end(),
0095               [&gctx](const auto& surf1, const auto& surf2) {
0096                 if (surf1->center(gctx).x() != surf2->center(gctx).x()) {
0097                   return surf1->center(gctx).x() < surf2->center(gctx).x();
0098                 }
0099                 if (surf1->center(gctx).y() != surf2->center(gctx).y()) {
0100                   return surf1->center(gctx).y() < surf2->center(gctx).y();
0101                 }
0102                 return surf1->center(gctx).z() < surf2->center(gctx).z();
0103               });
0104
0105     // Remove the duplicates
0106     surfaces.erase(std::unique(surfaces.begin(), surfaces.end()),
0107                    surfaces.end());
0108   }
0109
0110  private:
0111   /// Unroll the cast loop
0112   /// @param position is the position of the update call
0113   /// @param a is the array to be filled
0114   template <typename Array, std::size_t... idx>
0115   void fillCasts(const Vector3& position, Array& a,
0116                  std::index_sequence<idx...> /*indices*/) const {
0117     ((a[idx] = VectorHelpers::cast(position, casts[idx])), ...);
0118   }
0119 };
0120
0121 struct PathGridSurfacesGenerator {
0122   std::vector<Vector3> operator()(Vector3 startPosition,
0123                                   const Vector3& direction, ActsScalar stepSize,
0124                                   std::size_t numberOfSteps) const {
0125     std::vector<Vector3> pathCoordinates = {};
0126     pathCoordinates.reserve(numberOfSteps);
0127
0128     Vector3 position = std::move(startPosition);
0129     Vector3 step = stepSize * direction;
0130
0131     for (std::size_t i = 0; i < numberOfSteps; i++) {
0132       pathCoordinates.push_back(position);
0133       position = position + step;
0134     }
0135
0136     return pathCoordinates;
0137   }
0138 };
0139
0140 }  // namespace Acts::Experimental