chore: SurfaceMaterial without BinUtility

Core/include/Acts/Geometry/MaterialDesignatorBlueprintNode.hpp

@@ -56,7 +56,7 @@ class MaterialDesignatorBlueprintNode final : public BlueprintNode {
   /// It receives the populated portal shell from its only child and attaches
   /// material proxies by consulting the configuration stored in the node.
   /// @note Currently, this node will unconditionally attach
-  ///       @ref Acts::ProtoGridSurfaceMaterial
+  ///       @ref Acts::ProtoSurfaceMaterial
   ///
   /// @param options The global blueprint options
   /// @param gctx The geometry context (nominal usually)

Core/include/Acts/Material/AccumulatedSurfaceMaterial.hpp

@@ -11,11 +11,13 @@
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Material/AccumulatedMaterialSlab.hpp"
 #include "Acts/Material/MaterialSlab.hpp"
-#include "Acts/Utilities/BinUtility.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
+#include "Acts/Utilities/VectorHelpers.hpp"
 
 #include <array>
 #include <cstddef>
 #include <memory>
+#include <utility>
 #include <vector>
 
 namespace Acts {
@@ -51,10 +53,13 @@ class AccumulatedSurfaceMaterial {
   ///    - 0. : alongPre
   ///  ===> 1 Dimensional array
   ///
-  /// @param binUtility defines the binning structure on the surface
+  /// @param directedProtoAxes defines the binning structure on the surface
+  /// @param globalToLocalTransform transform from global to local 3D frame
   /// @param splitFactor is the pre/post splitting directive
-  explicit AccumulatedSurfaceMaterial(const BinUtility& binUtility,
-                                      double splitFactor = 0.);
+  explicit AccumulatedSurfaceMaterial(
+      std::vector<DirectedProtoAxis> directedProtoAxes,
+      Transform3 globalToLocalTransform = Transform3::Identity(),
+      double splitFactor = 0.);
 
   /// Copy Constructor
   ///
@@ -83,9 +88,13 @@ class AccumulatedSurfaceMaterial {
   /// Destructor
   ~AccumulatedSurfaceMaterial() = default;
 
-  /// Return the BinUtility
-  /// @return Reference to the bin utility used for material binning
-  const BinUtility& binUtility() const;
+  /// Return the DirectedProtoAxis descriptors
+  /// @return Reference to the directed proto axes used for material binning
+  const std::vector<DirectedProtoAxis>& directedProtoAxes() const;
+
+  /// Return the transform from global to local 3D frame
+  /// @return Reference to global-to-local transform
+  const Transform3& globalToLocalTransform() const;
 
   /// Assign a material properties object
   ///
@@ -154,8 +163,17 @@ class AccumulatedSurfaceMaterial {
   double splitFactor() const;
 
  private:
-  /// The helper for the bin finding
-  BinUtility m_binUtility{};
+  /// Correct potentially underflow/overflow IAxis bins into matrix bins.
+  static std::size_t correctedBinIndex(const IAxis& axis, double value);
+
+  /// Return material bins corresponding to a local 3D position.
+  std::array<std::size_t, 3> lookupBins(const Vector3& localPosition) const;
+
+  /// The helper for axis-based bin finding
+  std::vector<DirectedProtoAxis> m_directedProtoAxes{};
+
+  /// Global to local transform for bin lookups.
+  Transform3 m_globalToLocalTransform = Transform3::Identity();
 
   /// the split factor
   double m_splitFactor{0.};
@@ -164,8 +182,46 @@ class AccumulatedSurfaceMaterial {
   AccumulatedMatrix m_accumulatedMaterial;
 };
 
-inline const BinUtility& AccumulatedSurfaceMaterial::binUtility() const {
-  return m_binUtility;
+inline const std::vector<DirectedProtoAxis>&
+AccumulatedSurfaceMaterial::directedProtoAxes() const {
+  return m_directedProtoAxes;
+}
+
+inline const Transform3& AccumulatedSurfaceMaterial::globalToLocalTransform()
+    const {
+  return m_globalToLocalTransform;
+}
+
+inline std::size_t AccumulatedSurfaceMaterial::correctedBinIndex(
+    const IAxis& axis, double value) {
+  const std::size_t rawBin = axis.getBin(value);
+  const std::size_t nBins = axis.getNBins();
+  if (nBins == 0u || rawBin == 0u) {
+    return 0u;
+  }
+  if (rawBin > nBins) {
+    return nBins - 1u;
+  }
+  return rawBin - 1u;
+}
+
+inline std::array<std::size_t, 3> AccumulatedSurfaceMaterial::lookupBins(
+    const Vector3& localPosition) const {
+  if (m_directedProtoAxes.empty()) {
+    return {0u, 0u, 0u};
+  }
+  std::array<std::size_t, 3> bins = {0u, 0u, 0u};
+  bins[0] = correctedBinIndex(
+      m_directedProtoAxes[0u].getAxis(),
+      VectorHelpers::cast(localPosition,
+                          m_directedProtoAxes[0u].getAxisDirection()));
+  if (m_directedProtoAxes.size() > 1u) {
+    bins[1] = correctedBinIndex(
+        m_directedProtoAxes[1u].getAxis(),
+        VectorHelpers::cast(localPosition,
+                            m_directedProtoAxes[1u].getAxisDirection()));
+  }
+  return bins;
 }
 
 inline const AccumulatedSurfaceMaterial::AccumulatedMatrix&

Core/include/Acts/Material/BinnedSurfaceMaterial.hpp

@@ -12,8 +12,14 @@
 #include "Acts/Material/ISurfaceMaterial.hpp"
 #include "Acts/Material/MaterialSlab.hpp"
 #include "Acts/Utilities/BinUtility.hpp"
+#include "Acts/Utilities/GridAccessHelpers.hpp"
+#include "Acts/Utilities/ProtoAxis.hpp"
 
+#include <array>
 #include <iosfwd>
+#include <stdexcept>
+#include <utility>
+#include <vector>
 
 namespace Acts {
 
@@ -39,11 +45,26 @@ class BinnedSurfaceMaterial : public ISurfaceMaterial {
   /// @param fullProperties is the vector of properties as recorded (moved)
   /// @param splitFactor is the pre/post splitting directive
   /// @param mappingType is the type of surface mapping associated to the surface
+  [[deprecated(
+      "BinnedSurfaceMaterial BinUtility constructor is deprecated. "
+      "Use DirectedProtoAxis constructor instead.")]]
   BinnedSurfaceMaterial(const BinUtility& binUtility,
                         MaterialSlabVector fullProperties,
                         double splitFactor = 0.,
                         MappingType mappingType = MappingType::Default);
 
+  /// Explicit constructor with only full MaterialSlab,
+  /// for one-dimensional binning.
+  ///
+  /// @param directedProtoAxis defines axis direction and axis binning
+  /// @param fullProperties is the vector of properties as recorded (moved)
+  /// @param splitFactor is the pre/post splitting directive
+  /// @param mappingType is the type of surface mapping associated to the surface
+  BinnedSurfaceMaterial(DirectedProtoAxis directedProtoAxis,
+                        MaterialSlabVector fullProperties,
+                        double splitFactor = 0.,
+                        MappingType mappingType = MappingType::Default);
+
   /// Explicit constructor with only full MaterialSlab,
   /// for two-dimensional binning.
   ///
@@ -56,11 +77,26 @@ class BinnedSurfaceMaterial : public ISurfaceMaterial {
   /// @param fullProperties is the vector of properties as recorded (moved)
   /// @param splitFactor is the pre/post splitting directive
   /// @param mappingType is the type of surface mapping associated to the surface
+  [[deprecated(
+      "BinnedSurfaceMaterial BinUtility constructor is deprecated. "
+      "Use std::array<DirectedProtoAxis, 2> constructor instead.")]]
   BinnedSurfaceMaterial(const BinUtility& binUtility,
                         MaterialSlabMatrix fullProperties,
                         double splitFactor = 0.,
                         MappingType mappingType = MappingType::Default);
 
+  /// Explicit constructor with only full MaterialSlab,
+  /// for two-dimensional binning.
+  ///
+  /// @param directedProtoAxes defines axis directions and axis binnings
+  /// @param fullProperties is the matrix of properties as recorded (moved)
+  /// @param splitFactor is the pre/post splitting directive
+  /// @param mappingType is the type of surface mapping associated to the surface
+  BinnedSurfaceMaterial(std::array<DirectedProtoAxis, 2> directedProtoAxes,
+                        MaterialSlabMatrix fullProperties,
+                        double splitFactor = 0.,
+                        MappingType mappingType = MappingType::Default);
+
   /// Copy Move Constructor
   ///
   /// @param bsm is the source object to be copied
@@ -91,8 +127,15 @@ class BinnedSurfaceMaterial : public ISurfaceMaterial {
   BinnedSurfaceMaterial& scale(double factor) final;
 
   /// Return the BinUtility
-  /// @return Reference to the bin utility used for material binning
-  const BinUtility& binUtility() const;
+  /// @return BinUtility used for material binning (created on-the-fly)
+  [[deprecated(
+      "BinnedSurfaceMaterial::binUtility() is deprecated. "
+      "Use directedProtoAxes() instead.")]]
+  BinUtility binUtility() const;
+
+  /// Return the DirectedProtoAxis descriptors
+  /// @return Reference to the directed proto axes used for material binning
+  const std::vector<DirectedProtoAxis>& directedProtoAxes() const;
 
   /// @brief Retrieve the entire material slab matrix
   /// @return Reference to the complete matrix of material slabs
@@ -102,7 +145,10 @@ class BinnedSurfaceMaterial : public ISurfaceMaterial {
   const MaterialSlab& materialSlab(const Vector2& lp) const final;
 
   /// @copydoc ISurfaceMaterial::materialSlab(const Vector3&) const
-  const MaterialSlab& materialSlab(const Vector3& gp) const final;
+  ///
+  /// For this class the provided 3D position is expected to already be in the
+  /// local surface frame.
+  const MaterialSlab& materialSlab(const Vector3& lp3D) const final;
 
   using ISurfaceMaterial::materialSlab;
 
@@ -112,15 +158,78 @@ class BinnedSurfaceMaterial : public ISurfaceMaterial {
   std::ostream& toStream(std::ostream& sl) const final;
 
  private:
-  /// The helper for the bin finding
-  BinUtility m_binUtility;
+  /// Convert legacy BinUtility setup to DirectedProtoAxis.
+  static std::vector<DirectedProtoAxis> convertBinUtility(
+      const BinUtility& binUtility);
+
+  /// Correct potentially underflow/overflow IAxis bins into matrix bins.
+  static std::size_t correctedBinIndex(const IAxis& axis, double value);
+
+  /// The helper for axis-based bin finding
+  std::vector<DirectedProtoAxis> m_directedProtoAxes;
 
   /// The five different MaterialSlab
   MaterialSlabMatrix m_fullMaterial;
 };
 
-inline const BinUtility& BinnedSurfaceMaterial::binUtility() const {
-  return m_binUtility;
+inline BinUtility BinnedSurfaceMaterial::binUtility() const {
+  BinUtility converted;
+  for (const auto& directedProtoAxis : m_directedProtoAxes) {
+    converted += BinUtility(BinningData(directedProtoAxis));
+  }
+  return converted;
+}
+
+inline const std::vector<DirectedProtoAxis>&
+BinnedSurfaceMaterial::directedProtoAxes() const {
+  return m_directedProtoAxes;
+}
+
+inline std::vector<DirectedProtoAxis> BinnedSurfaceMaterial::convertBinUtility(
+    const BinUtility& binUtility) {
+  const auto& binningData = binUtility.binningData();
+  if (binningData.empty() || binningData.size() > 2u) {
+    throw std::invalid_argument(
+        "BinnedSurfaceMaterial supports only 1D/2D binning.");
+  }
+
+  std::vector<DirectedProtoAxis> directedProtoAxes;
+  directedProtoAxes.reserve(binningData.size());
+  for (const auto& bData : binningData) {
+    const AxisBoundaryType boundaryType = bData.option == closed
+                                              ? AxisBoundaryType::Closed
+                                              : AxisBoundaryType::Bound;
+    if (bData.type == equidistant) {
+      directedProtoAxes.emplace_back(
+          bData.binvalue, boundaryType, static_cast<double>(bData.min),
+          static_cast<double>(bData.max), bData.bins());
+      continue;
+    }
+    std::vector<double> edges;
+    edges.reserve(bData.boundaries().size());
+    for (const auto edge : bData.boundaries()) {
+      edges.push_back(static_cast<double>(edge));
+    }
+    directedProtoAxes.emplace_back(bData.binvalue, boundaryType, edges);
+  }
+
+  return directedProtoAxes;
+}
+
+inline std::size_t BinnedSurfaceMaterial::correctedBinIndex(const IAxis& axis,
+                                                            double value) {
+  const std::size_t rawBin = axis.getBin(value);
+  const std::size_t nBins = axis.getNBins();
+  if (nBins == 0u) {
+    return 0u;
+  }
+  if (rawBin == 0u) {
+    return 0u;
+  }
+  if (rawBin > nBins) {
+    return nBins - 1u;
+  }
+  return rawBin - 1u;
 }
 
 inline const MaterialSlabMatrix& BinnedSurfaceMaterial::fullMaterial() const {