EIC code displayed by LXR master/​acts/​Core/​include/​Acts/​Utilities/​Grid.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-04 08:20:08

 // 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/.
 
 #pragma once
 
 #include "Acts/Utilities/Axis.hpp"
 #include "Acts/Utilities/Enumerate.hpp"
 #include "Acts/Utilities/GridIterator.hpp"
 #include "Acts/Utilities/IGrid.hpp"
 #include "Acts/Utilities/Interpolation.hpp"
 #include "Acts/Utilities/MultiAxis.hpp"
 #include "Acts/Utilities/TypeTag.hpp"
 #include "Acts/Utilities/detail/MultiAxisHelper.hpp"
 
 #include <algorithm>
 #include <array>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
 #include <vector>
 
 namespace Acts {
 
 /// class for describing a regular multi-dimensional grid
 ///
 /// @tparam T    type of values stored inside the bins of the grid
 /// @tparam Axes parameter pack of axis types defining the grid
 ///
 /// Class describing a multi-dimensional, regular grid which can store objects
 /// in its multi-dimensional bins. Bins are hyper-boxes and can be accessed
 /// either by global bin index, local bin indices or position.
 ///
 /// @note @c T must be default-constructible.
 /// @note @c T must not be @c bool, because @c std::vector<bool> is special
 ///          and does not return references to its elements.
 template <typename T, class... Axes>
   requires(std::is_default_constructible_v<T> && !std::is_same_v<T, bool>)
 class Grid final : public IGrid {
  public:
   /// number of dimensions of the grid
   static constexpr std::size_t DIM = sizeof...(Axes);
 
   /// multi axis type
   using multi_axis_t = MultiAxis<Axes...>;
   /// type of values stored
   using value_type = T;
   /// reference type to values stored
   using reference = value_type&;
   /// constant reference type to values stored
   using const_reference = const value_type&;
   /// type for points in d-dimensional grid space
   using point_t = std::array<double, DIM>;
   /// index type using local bin indices along each axis
   using index_t = std::array<std::size_t, DIM>;
   /// global iterator type
   using global_iterator_t = GridGlobalIterator<T, Axes...>;
   /// local iterator type
   using local_iterator_t = GridLocalIterator<T, Axes...>;
 
   /// Constructor from const axis tuple, this will allow
   /// creating a grid with a different value type from a template
   /// grid object.
   ///
   /// @param axes
   explicit Grid(const std::tuple<Axes...>& axes) : m_axes(axes) {
     m_values.resize(size());
   }
 
   /// Move constructor from axis tuple
   /// @param axes
   explicit Grid(std::tuple<Axes...>&& axes) : m_axes(std::move(axes)) {
     m_values.resize(size());
   }
 
   /// constructor from parameters pack of axes
   /// @param axes
   explicit Grid(Axes&&... axes) : m_axes(std::forward_as_tuple(axes...)) {
     m_values.resize(size());
   }
 
   /// constructor from parameters pack of axes
   /// @param axes
   explicit Grid(const Axes&... axes) : m_axes(std::tuple(axes...)) {
     m_values.resize(size());
   }
 
   /// constructor from parameters pack of axes and type tag
   /// @param axes
   explicit Grid(TypeTag<T> /*tag*/, Axes&&... axes)
       : m_axes(std::forward_as_tuple(axes...)) {
     m_values.resize(size());
   }
 
   /// constructor from parameters pack of axes and type tag
   /// @param axes
   explicit Grid(TypeTag<T> /*tag*/, const Axes&... axes)
       : m_axes(std::tuple(axes...)) {
     m_values.resize(size());
   }
 
   /// Move constructor from axis tuple
   /// @param axes
   explicit Grid(multi_axis_t axes) : m_axes(std::move(axes)) {
     m_values.resize(size());
   }
 
   /// constructor from parameters pack of axes and type tag
   /// @param axes
   explicit Grid(TypeTag<T> /*tag*/, multi_axis_t axes)
       : m_axes(std::move(axes)) {
     m_values.resize(size());
   }
 
   /// access value stored in bin for a given point
   ///
   /// @tparam Point any type with point semantics supporting component access
   ///               through @c operator[]
   /// @param point point used to look up the corresponding bin in the
   ///                   grid
   /// @return reference to value stored in bin containing the given point
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   ///
   /// @note The look-up considers under-/overflow bins along each axis.
   ///       Therefore, the look-up will never fail.
   //
   template <class Point>
   reference atPosition(const Point& point) {
     return m_values.at(m_axes.getGlobalBinFromPoint(point));
   }
 
   /// access value stored in bin for a given point
   ///
   /// @tparam Point any type with point semantics supporting component access
   ///               through @c operator[]
   /// @param point point used to look up the corresponding bin in the
   ///                   grid
   /// @return const-reference to value stored in bin containing the given
   ///         point
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   ///
   /// @note The look-up considers under-/overflow bins along each axis.
   ///       Therefore, the look-up will never fail.
   template <class Point>
   const_reference atPosition(const Point& point) const {
     return m_values.at(m_axes.getGlobalBinFromPoint(point));
   }
 
   /// access value stored in bin with given global bin number
   ///
   /// @param bin global bin number
   /// @return reference to value stored in bin containing the given
   ///         point
   reference at(std::size_t bin) { return m_values.at(bin); }
 
   /// access value stored in bin with given global bin number
   ///
   /// @param bin global bin number
   /// @return const-reference to value stored in bin containing the given
   ///         point
   const_reference at(std::size_t bin) const { return m_values.at(bin); }
 
   /// access value stored in bin with given local bin numbers
   ///
   /// @param localBins local bin indices along each axis
   /// @return reference to value stored in bin containing the given
   ///         point
   ///
   /// @pre All local bin indices must be a valid index for the corresponding
   ///      axis (including the under-/overflow bin for this axis).
   reference atLocalBins(const index_t& localBins) {
     return m_values.at(m_axes.getGlobalBinFromLocalBins(localBins));
   }
 
   /// access value stored in bin with given local bin numbers
   ///
   /// @param localBins local bin indices along each axis
   /// @return const-reference to value stored in bin containing the given
   ///         point
   ///
   /// @pre All local bin indices must be a valid index for the corresponding
   ///      axis (including the under-/overflow bin for this axis).
   const_reference atLocalBins(const index_t& localBins) const {
     return m_values.at(m_axes.getGlobalBinFromLocalBins(localBins));
   }
 
   /// @copydoc Acts::IGrid::atLocalBinsAny
   std::any atLocalBinsAny(const AnyIndexType& indices) const override {
     return &atLocalBins(toIndexType(indices));
   }
 
   /// @copydoc Acts::IGrid::atLocalBinsAny
   std::any atLocalBinsAny(const AnyIndexType& indices) override {
     return &atLocalBins(toIndexType(indices));
   }
 
   /// get global bin indices for closest points on grid
   ///
   /// @tparam Point any type with point semantics supporting component access
   ///               through @c operator[]
   /// @param position point of interest
   /// @return Iterable thatemits the indices of bins whose lower-left corners
   ///         are the closest points on the grid to the input.
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid. It must lie
   ///      within the grid range (i.e. not within a under-/overflow bin).
   /// @deprecated Use grid.multiAxis().getClosestPointsIndices(point) instead
   template <class Point>
   [[deprecated("Use grid.multiAxis().getClosestPointsIndices(point) instead")]]
   detail::FlatNeighborHoodIndices<DIM> closestPointsIndices(
       const Point& position) const {
     return m_axes.getClosestPointsIndices(position);
   }
 
   /// dimensionality of grid
   ///
   /// @return number of axes spanning the grid
   std::size_t dimensions() const override { return DIM; }
 
   /// Get the multi-axis object for the grid
   /// @return The multi-axis object for the grid
   const IMultiAxis& multiAxisAny() const override { return m_axes; }
 
   /// Get the multi-axis object for the grid
   /// @return The multi-axis object for the grid
   const multi_axis_t& multiAxis() const { return m_axes; }
 
   const IAxis& axis(std::size_t index) const override {
     return m_axes.getAxis(index);
   }
 
   /// @copydoc Acts::IGrid::valueType
   const std::type_info& valueType() const override { return typeid(T); }
 
   /// get center position of bin with given local bin numbers
   ///
   /// @param localBins local bin indices along each axis
   /// @return center position of bin
   ///
   /// @pre All local bin indices must be a valid index for the corresponding
   ///      axis (excluding the under-/overflow bins for each axis).
   /// @deprecated Use grid.multiAxis().getBinCenter(localBins) instead
   [[deprecated("Use grid.multiAxis().getBinCenter(localBins) instead")]]
   point_t binCenter(const index_t& localBins) const {
     return m_axes.getBinCenter(localBins);
   }
 
   /// determine global index for bin containing the given point
   ///
   /// @tparam Point any type with point semantics supporting component access
   ///               through @c operator[]
   ///
   /// @param point point to look up in the grid
   /// @return global index for bin containing the given point
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   /// @note This could be a under-/overflow bin along one or more axes.
   /// @deprecated Use grid.multiAxis().getGlobalBinFromPoint(point) instead
   template <class Point>
   [[deprecated("Use grid.multiAxis().getGlobalBinFromPoint(point) instead")]]
   std::size_t globalBinFromPosition(const Point& point) const {
     return m_axes.getGlobalBinFromPoint(point);
   }
 
   /// determine global bin index from local bin indices along each axis
   ///
   /// @param localBins local bin indices along each axis
   /// @return global index for bin defined by the local bin indices
   ///
   /// @pre All local bin indices must be a valid index for the corresponding
   ///      axis (including the under-/overflow bin for this axis).
   /// @deprecated Use grid.multiAxis().getGlobalBinFromLocalBins(localBins)
   ///             instead
   [[deprecated(
       "Use grid.multiAxis().getGlobalBinFromLocalBins(localBins) instead")]]
   std::size_t globalBinFromLocalBins(const index_t& localBins) const {
     return m_axes.getGlobalBinFromLocalBins(localBins);
   }
 
   ///  determine global bin index of the bin with the lower left edge
   ///         closest to the given point for each axis
   ///
   /// @tparam Point any type with point semantics supporting component access
   ///               through @c operator[]
   ///
   /// @param point point to look up in the grid
   /// @return global index for bin containing the given point
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   /// @note This could be a under-/overflow bin along one or more axes.
   /// @deprecated Use grid.multiAxis().getGlobalBinFromLowerLeftEdge(point)
   ///             instead
   template <class Point>
   [[deprecated(
       "Use grid.multiAxis().getGlobalBinFromLowerLeftEdge(point) instead")]]
   std::size_t globalBinFromFromLowerLeftEdge(const Point& point) const {
     return m_axes.getGlobalBinFromLowerLeftEdge(point);
   }
 
   ///  determine local bin index for each axis from the given point
   ///
   /// @tparam Point any type with point semantics supporting component access
   ///               through @c operator[]
   ///
   /// @param point point to look up in the grid
   /// @return array with local bin indices along each axis (in same order as
   ///         given @c axes object)
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   /// @note This could be a under-/overflow bin along one or more axes.
   /// @deprecated Use grid.multiAxis().getLocalBinsFromPoint(point) instead
   template <class Point>
   [[deprecated("Use grid.multiAxis().getLocalBinsFromPoint(point) instead")]]
   index_t localBinsFromPosition(const Point& point) const {
     return m_axes.getLocalBinsFromPoint(point);
   }
 
   /// determine local bin index for each axis from global bin index
   ///
   /// @param bin global bin index
   /// @return array with local bin indices along each axis (in same order as
   ///         given @c axes object)
   ///
   /// @note Local bin indices can contain under-/overflow bins along the
   ///       corresponding axis.
   /// @deprecated Use grid.multiAxis().getLocalBinsFromGlobalBin(bin) instead
   [[deprecated("Use grid.multiAxis().getLocalBinsFromGlobalBin(bin) instead")]]
   index_t localBinsFromGlobalBin(std::size_t bin) const {
     return m_axes.getLocalBinsFromGlobalBin(bin);
   }
 
   ///  determine local bin index of the bin with the lower left edge
   ///         closest to the given point for each axis
   ///
   /// @tparam Point any type with point semantics supporting component access
   ///               through @c operator[]
   ///
   /// @param point point to look up in the grid
   /// @return array with local bin indices along each axis (in same order as
   ///         given @c axes object)
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   /// @note This could be a under-/overflow bin along one or more axes.
   /// @deprecated Use grid.multiAxis().getLocalBinsFromLowerLeftEdge(point)
   ///             instead
   template <class Point>
   [[deprecated(
       "Use grid.multiAxis().getLocalBinsFromLowerLeftEdge(point) instead")]]
   index_t localBinsFromLowerLeftEdge(const Point& point) const {
     return m_axes.getLocalBinsFromLowerLeftEdge(point);
   }
 
   /// retrieve lower-left bin edge from set of local bin indices
   ///
   /// @param localBins local bin indices along each axis
   /// @return generalized lower-left bin edge position
   ///
   /// @pre @c localBins must only contain valid bin indices (excluding
   ///      underflow bins).
   /// @deprecated Use grid.multiAxis().getLowerLeftBinEdge(localBins) instead
   [[deprecated("Use grid.multiAxis().getLowerLeftBinEdge(localBins) instead")]]
   point_t lowerLeftBinEdge(const index_t& localBins) const {
     return m_axes.getLowerLeftBinEdge(localBins);
   }
 
   /// retrieve upper-right bin edge from set of local bin indices
   ///
   /// @param localBins local bin indices along each axis
   /// @return generalized upper-right bin edge position
   ///
   /// @pre @c localBins must only contain valid bin indices (excluding
   ///      overflow bins).
   /// @deprecated Use grid.multiAxis().getUpperRightBinEdge(localBins) instead
   [[deprecated("Use grid.multiAxis().getUpperRightBinEdge(localBins) instead")]]
   point_t upperRightBinEdge(const index_t& localBins) const {
     return m_axes.getUpperRightBinEdge(localBins);
   }
 
   /// get bin width along each specific axis
   ///
   /// @return array giving the bin width alonf all axes
   /// @deprecated Use grid.multiAxis().getBinWidth({}) instead
   [[deprecated("Use grid.multiAxis().getBinWidth({}) instead")]]
   point_t binWidth() const {
     return m_axes.getBinWidth({});
   }
 
   /// get number of bins along each specific axis
   ///
   /// @return array giving the number of bins along all axes
   ///
   /// @note Not including under- and overflow bins
   /// @deprecated Use grid.multiAxis().getNBins() instead
   [[deprecated("Use grid.multiAxis().getNBins() instead")]]
   index_t numLocalBins() const {
     return m_axes.getNBins();
   }
 
   /// get the minimum value of all axes of one grid
   ///
   /// @return array returning the minima of all given axes
   /// @deprecated Use grid.multiAxis().getMinPoint() instead
   [[deprecated("Use grid.multiAxis().getMinPoint() instead")]]
   point_t minPosition() const {
     return m_axes.getMinPoint();
   }
 
   /// get the maximum value of all axes of one grid
   ///
   /// @return array returning the maxima of all given axes
   /// @deprecated Use grid.multiAxis().getMaxPoint() instead
   [[deprecated("Use grid.multiAxis().getMaxPoint() instead")]]
   point_t maxPosition() const {
     return m_axes.getMaxPoint();
   }
 
   /// set all overflow and underflow bins to a certain value
   ///
   /// @param value value to be inserted in every overflow and underflow
   ///                   bin of the grid.
   ///
   void setExteriorBins(const value_type& value) {
     for (std::size_t index :
          detail::MultiAxisHelper::exteriorBinIndices(m_axes.getAxesTuple())) {
       at(index) = value;
     }
   }
 
   /// interpolate grid values to given position
   ///
   /// @tparam Point type specifying geometric positions
   /// @tparam U     dummy template parameter identical to @c T
   ///
   /// @param point location to which to interpolate grid values. The
   ///                   position must be within the grid dimensions and not
   ///                   lie in an under-/overflow bin along any axis.
   ///
   /// @return interpolated value at given position
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   ///
   /// @note This function is available only if the following conditions are
   /// fulfilled:
   /// - Given @c U and @c V of value type @c T as well as two @c double
   /// @c a and @c b, then the following must be a valid expression <tt>a * U + b
   /// * V</tt> yielding an object which is (implicitly) convertible to @c T.
   /// - @c Point must represent a d-dimensional position and support
   /// coordinate access using @c operator[] which should return a @c
   /// double (or a value which is implicitly convertible). Coordinate
   /// indices must start at 0.
   /// @note Bin values are interpreted as being the field values at the
   /// lower-left corner of the corresponding hyper-box.
   template <class Point>
   T interpolate(const Point& point) const {
     // get local indices for current bin
     // value of bin is interpreted as being the field value at its lower left
     // corner
     const auto llIndices = m_axes.getLocalBinsFromPoint(point);
 
     // get global indices for all surrounding corner points
     const auto closestIndices =
         m_axes.getNeighborHoodIndices(llIndices, {0, 1});
 
     // there are 2^DIM corner points used during the interpolation
     constexpr std::size_t nCorners = 1 << DIM;
 
     // construct vector of pairs of adjacent bin centers and values
     std::array<value_type, nCorners> neighbors{};
 
     // get values on grid points
     std::size_t i = 0;
     for (const auto index : closestIndices) {
       neighbors.at(i) = at(index);
       ++i;
     }
 
     return Acts::interpolate(point, m_axes.getLowerLeftBinEdge(llIndices),
                              m_axes.getUpperRightBinEdge(llIndices), neighbors);
   }
 
   /// check whether given point is inside grid limits
   ///
   /// @param position Point to check for inclusion within grid boundaries
   /// @return @c true if \f$\text{xmin_i} \le x_i < \text{xmax}_i \forall i=0,
   ///         \dots, d-1\f$, otherwise @c false
   ///
   /// @pre The given @c Point type must represent a point in d (or higher)
   ///      dimensions where d is dimensionality of the grid.
   ///
   /// @post If @c true is returned, the global bin containing the given point
   ///       is a valid bin, i.e. it is neither a underflow nor an overflow bin
   ///       along any axis.
   /// @deprecated Use grid.multiAxis().isInside(position) instead
   template <class Point>
   [[deprecated("Use grid.multiAxis().isInside(position) instead")]]
   bool isInside(const Point& position) const {
     return m_axes.isInside(position);
   }
 
   /// get global bin indices for neighborhood
   ///
   /// @param localBins center bin defined by local bin indices along each
   ///                       axis
   /// @param size      size of neighborhood determining how many adjacent
   ///                       bins along each axis are considered
   /// @return set of global bin indices for all bins in neighborhood
   ///
   /// @note Over-/underflow bins are included in the neighborhood.
   /// @note The @c size parameter sets the range by how many units each local
   ///       bin index is allowed to be varied. All local bin indices are
   ///       varied independently, that is diagonal neighbors are included.
   ///       Ignoring the truncation of the neighborhood size reaching beyond
   ///       over-/underflow bins, the neighborhood is of size \f$2 \times
   ///       \text{size}+1\f$ along each dimension.
   /// @deprecated Use grid.multiAxis().getNeighborHoodIndices(localBins, size)
   ///             instead
   [[deprecated(
       "Use grid.multiAxis().getNeighborHoodIndices(localBins, size) instead")]]
   detail::FlatNeighborHoodIndices<DIM> neighborHoodIndices(
       const index_t& localBins, std::size_t size = 1u) const {
     return m_axes.getNeighborHoodIndices(localBins, size);
   }
 
   /// get global bin   indices for neighborhood
   ///
   /// @param localBins   center bin defined by local bin indices along
   ///                         each axis. If size is negative, center bin
   ///                         is not returned.
   /// @param sizePerAxis size of neighborhood for each axis, how many
   ///                         adjacent bins along each axis are considered
   /// @return set of global bin indices for all bins in neighborhood
   ///
   /// @note Over-/underflow bins are included in the neighborhood.
   /// @note The @c size parameter sets the range by how many units each local
   ///       bin index is allowed to be varied. All local bin indices are
   ///       varied independently, that is diagonal neighbors are included.
   ///       Ignoring the truncation of the neighborhood size reaching beyond
   ///       over-/underflow bins, the neighborhood is of size \f$2 \times
   ///       \text{size}+1\f$ along each dimension.
   /// @deprecated Use grid.multiAxis().getNeighborHoodIndices(localBins,
   ///             sizePerAxis) instead
   [[deprecated(
       "Use grid.multiAxis().getNeighborHoodIndices(localBins, sizePerAxis) "
       "instead")]]
   detail::FlatNeighborHoodIndices<DIM> neighborHoodIndices(
       const index_t& localBins,
       std::array<std::pair<int, int>, DIM>& sizePerAxis) const {
     return m_axes.getNeighborHoodIndices(localBins, sizePerAxis);
   }
 
   /// total number of bins
   ///
   /// @param fullCounter Whether to include under-and overflow bins in the count
   /// @return total number of bins in the grid
   ///
   /// @note This number contains under-and overflow bins along all axes.
   std::size_t size(bool fullCounter = true) const {
     return m_axes.getNTotalBins(fullCounter);
   }
 
   /// Convenience function to convert the type of the grid
   /// to hold another object type.
   ///
   /// @tparam U the new grid value type
   ///
   /// @return a new grid with the same axes and a different value type
   template <typename U>
   Grid<U, Axes...> convertType() const {
     Grid<U, Axes...> cGrid(m_axes);
     return cGrid;
   }
 
   /// Convenience function to convert the type of the grid
   /// to hold another object type.
   ///
   /// @tparam converter_t the converter type
   ///
   /// This is designed to be most flexible with a converter object
   /// as a visitor. If needed, such a visitor could also use
   /// caching or other techniques to speed up the conversion.
   ///
   /// @param cVisitor the converter object as visitor
   ///
   /// @return a new grid with the same axes and a different value type
   template <typename converter_t>
   Grid<typename converter_t::value_type, Axes...> convertGrid(
       converter_t& cVisitor) const {
     Grid<typename converter_t::value_type, Axes...> cGrid(m_axes);
     // Loop through the values and convert them
     for (std::size_t i = 0; i < size(); i++) {
       cGrid.at(i) = cVisitor(at(i));
     }
     return cGrid;
   }
 
   /// get the axes as a tuple
   /// @return Reference to the tuple containing all grid axes
   /// @deprecated Use grid.multiAxis().getAxesTuple() instead
   [[deprecated("Use grid.multiAxis().getAxesTuple() instead")]]
   const std::tuple<Axes...>& axesTuple() const {
     return m_axes.getAxesTuple();
   }
 
   /// get the axes as an array of IAxis pointers
   /// @return Vector containing pointers to all grid axes
   AnyAxesVector axes() const override { return m_axes.getAnyAxesVector(); }
 
   /// begin iterator for global bins
   /// @return Iterator pointing to the first global bin
   global_iterator_t begin() const { return global_iterator_t(*this, 0); }
 
   /// end iterator for global bins
   /// @return Iterator pointing one past the last global bin
   global_iterator_t end() const { return global_iterator_t(*this, size()); }
 
   /// begin iterator for local bins
   ///
   /// @param navigator is local navigator for the grid
   /// @return Iterator pointing to the first local bin
   local_iterator_t begin(
       const std::array<std::vector<std::size_t>, DIM>& navigator) const {
     std::array<std::size_t, DIM> localBin{};
     return local_iterator_t(*this, std::move(localBin), navigator);
   }
 
   /// end iterator for local bins
   ///
   /// @param navigator is local navigator for the grid
   /// @return Iterator pointing one past the last local bin
   local_iterator_t end(
       const std::array<std::vector<std::size_t>, DIM>& navigator) const {
     std::array<std::size_t, DIM> endline{};
     for (std::size_t i(0ul); i < DIM; ++i) {
       endline[i] = navigator[i].size();
     }
     return local_iterator_t(*this, std::move(endline), navigator);
   }
 
  protected:
   void toStream(std::ostream& os) const override { os << m_axes; }
 
  private:
   /// multi axis for the grid
   multi_axis_t m_axes;
   /// linear value store for each bin
   std::vector<T> m_values;
 
   static index_t toIndexType(const AnyIndexType& indices) {
     if (indices.size() != DIM) {
       throw std::invalid_argument("Invalid number of indices");
     }
     index_t concrete;
     std::ranges::copy(indices, concrete.begin());
     return concrete;
   }
 };
 
 /// Deduction guide for Grid with rvalue reference axes
 /// @param axes Variable number of axes (rvalue references)
 template <typename T, class... Axes>
 Grid(TypeTag<T> /*type*/, Axes&&... axes) -> Grid<T, Axes...>;
 
 /// Deduction guide for Grid with lvalue reference axes
 /// @param axes Variable number of axes (lvalue references)
 template <typename T, class... Axes>
 Grid(TypeTag<T> /*type*/, Axes&... axes) -> Grid<T, Axes...>;
 
 /// @brief Helper method to create a 1D grid from a single type-erased axis
 ///
 /// @tparam payload_t the grid payload type
 ///
 /// @param a the axis
 ///
 /// @return an IGrid unique ptr and hence transfers ownership
 template <typename payload_t>
 std::unique_ptr<IGrid> makeGrid(const IAxis& a) {
   return a.visit(
       [&]<typename AxisTypeA>(const AxisTypeA& axis) -> std::unique_ptr<IGrid> {
         using GridType = Grid<payload_t, AxisTypeA>;
         return std::make_unique<GridType>(axis);
       });
 }
 
 /// @brief Helper method to create a 2D grid from two type-erased axes
 ///
 /// @tparam payload_t the grid payload type
 ///
 /// @param a the first axis
 /// @param b the second axis
 ///
 /// @return an IGrid unique ptr and hence transfers ownership
 template <typename payload_t>
 std::unique_ptr<IGrid> makeGrid(const IAxis& a, const IAxis& b) {
   return a.visit([&]<typename AxisTypeA>(
                      const AxisTypeA& axisA) -> std::unique_ptr<IGrid> {
     return b.visit([&]<typename AxisTypeB>(
                        const AxisTypeB& axisB) -> std::unique_ptr<IGrid> {
       using GridType = Grid<payload_t, AxisTypeA, AxisTypeB>;
       return std::make_unique<GridType>(axisA, axisB);
     });
   });
 }
 
 }  // namespace Acts

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