refactor!: SSS Seeding: Store dynamic variables instead of constantly copying them (acts-project#1966)

Built on top of acts-project#1948 

Dynamic variables are stored in the `SpacePointData` object. It looks like ~95% of the strip space points will have to use these variables during the seed finding process.

Author: CarloVarni

Core/include/Acts/EventData/SpacePointData.hpp

@@ -8,6 +8,8 @@
 
 #pragma once
 
+#include "Acts/Definitions/Algebra.hpp"
+
 #include <limits>
 #include <vector>
 
@@ -44,18 +46,75 @@ class SpacePointData {
   void setQuality(std::size_t idx, const float& value);
   void setDeltaR(std::size_t idx, const float& value);
 
-  /// @brief Reserve memory
-  void reserve(std::size_t n);
-
   /// @brief Resize vectors
-  void resize(std::size_t n);
+  void resize(std::size_t n, bool resizeDynamic = false);
 
   /// @brief clear vectors
   void clear();
 
+  ///
+  bool hasDynamicVariable() const { return not m_topHalfStripLength.empty(); }
+
+  const float& getTopHalfStripLength(std::size_t idx) const {
+    return m_topHalfStripLength[idx];
+  }
+
+  const float& getBottomHalfStripLength(std::size_t idx) const {
+    return m_bottomHalfStripLength[idx];
+  }
+
+  const Acts::Vector3& getTopStripDirection(std::size_t idx) const {
+    return m_topStripDirection[idx];
+  }
+
+  const Acts::Vector3& getBottomStripDirection(std::size_t idx) const {
+    return m_bottomStripDirection[idx];
+  }
+
+  const Acts::Vector3& getStripCenterDistance(std::size_t idx) const {
+    return m_stripCenterDistance[idx];
+  }
+
+  const Acts::Vector3& getTopStripCenterPosition(std::size_t idx) const {
+    return m_topStripCenterPosition[idx];
+  }
+
+  void setTopHalfStripLength(std::size_t idx, const float& value) {
+    m_topHalfStripLength[idx] = value;
+  }
+
+  void setBottomHalfStripLength(std::size_t idx, const float& value) {
+    m_bottomHalfStripLength[idx] = value;
+  }
+
+  void setTopStripDirection(std::size_t idx, const Acts::Vector3& value) {
+    m_topStripDirection[idx] = value;
+  }
+
+  void setBottomStripDirection(std::size_t idx, const Acts::Vector3& value) {
+    m_bottomStripDirection[idx] = value;
+  }
+
+  void setStripCenterDistance(std::size_t idx, const Acts::Vector3& value) {
+    m_stripCenterDistance[idx] = value;
+  }
+
+  void setTopStripCenterPosition(std::size_t idx, const Acts::Vector3& value) {
+    m_topStripCenterPosition[idx] = value;
+  }
+
  private:
+  /// Mutable variables
   std::vector<float> m_quality{};
   std::vector<float> m_deltaR{};
+
+  /// dynamic variables
+  std::vector<float> m_topHalfStripLength{};
+  std::vector<float> m_bottomHalfStripLength{};
+  std::vector<Acts::Vector3> m_topStripDirection{};
+  std::vector<Acts::Vector3> m_bottomStripDirection{};
+  std::vector<Acts::Vector3> m_stripCenterDistance{};
+  std::vector<Acts::Vector3> m_topStripCenterPosition{};
 };
 
 inline const float& SpacePointData::quality(std::size_t idx) const {
@@ -76,19 +135,33 @@ inline void SpacePointData::setDeltaR(std::size_t idx, const float& value) {
   m_deltaR[idx] = value;
 }
 
-inline void SpacePointData::reserve(std::size_t n) {
-  m_quality.reserve(n);
-  m_deltaR.reserve(n);
-}
+inline void SpacePointData::resize(std::size_t n, bool resizeDynamic) {
+  clear();
 
-inline void SpacePointData::resize(std::size_t n) {
   m_quality.resize(n, -std::numeric_limits<float>::infinity());
   m_deltaR.resize(n, 0.);
+
+  if (resizeDynamic) {
+    m_topHalfStripLength.resize(n, 0.);
+    m_bottomHalfStripLength.resize(n, 0.);
+    m_topStripDirection.resize(n, {0, 0, 0});
+    m_bottomStripDirection.resize(n, {0, 0, 0});
+    m_stripCenterDistance.resize(n, {0, 0, 0});
+    m_topStripCenterPosition.resize(n, {0, 0, 0});
+  }
 }
 
 inline void SpacePointData::clear() {
+  // mutable variables
   m_quality.clear();
   m_deltaR.clear();
+  // dynamicvariables
+  m_topHalfStripLength.clear();
+  m_bottomHalfStripLength.clear();
+  m_topStripDirection.clear();
+  m_bottomStripDirection.clear();
+  m_stripCenterDistance.clear();
+  m_topStripCenterPosition.clear();
 }
 
 }  // namespace Acts

Core/include/Acts/Seeding/SeedFinder.hpp

@@ -138,7 +138,8 @@ class SeedFinder {
       out_range_t& outVec, const float& deltaRMinSP, const float& deltaRMaxSP,
       bool isBottom) const;
 
-  void filterCandidates(const InternalSpacePoint<external_spacepoint_t>& SpM,
+  void filterCandidates(Acts::SpacePointData& spacePointData,
+                        const InternalSpacePoint<external_spacepoint_t>& SpM,
                         const Acts::SeedFinderOptions& options,
                         SeedFilterState& seedFilterState,
                         SeedingState& state) const;

Core/include/Acts/Seeding/SeedFinder.ipp

@@ -161,7 +161,8 @@ void SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
     }
 
     // filter candidates
-    filterCandidates(*spM.get(), options, seedFilterState, state);
+    filterCandidates(state.spacePointData, *spM.get(), options, seedFilterState,
+                     state);
 
     m_config.seedFilter->filterSeeds_1SpFixed(
         state.spacePointData, state.candidates_collector,
@@ -297,6 +298,7 @@ SeedFinder<external_spacepoint_t, platform_t>::getCompatibleDoublets(
 template <typename external_spacepoint_t, typename platform_t>
 
 inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
+    Acts::SpacePointData& spacePointData,
     const InternalSpacePoint<external_spacepoint_t>& spM,
     const Acts::SeedFinderOptions& options, SeedFilterState& seedFilterState,
     SeedingState& state) const {
@@ -435,7 +437,8 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
             cosTheta * std::sqrt(1 + A0 * A0)};
 
         double rMTransf[3];
-        if (!xyzCoordinateCheck(m_config, spM, positionMiddle, rMTransf)) {
+        if (!xyzCoordinateCheck(spacePointData, m_config, spM, positionMiddle,
+                                rMTransf)) {
           continue;
         }
 
@@ -450,7 +453,8 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
 
         auto spB = state.compatBottomSP[b];
         double rBTransf[3];
-        if (!xyzCoordinateCheck(m_config, *spB, positionBottom, rBTransf)) {
+        if (!xyzCoordinateCheck(spacePointData, m_config, *spB, positionBottom,
+                                rBTransf)) {
           continue;
         }
 
@@ -464,7 +468,8 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
 
         auto spT = state.compatTopSP[t];
         double rTTransf[3];
-        if (!xyzCoordinateCheck(m_config, *spT, positionTop, rTTransf)) {
+        if (!xyzCoordinateCheck(spacePointData, m_config, *spT, positionTop,
+                                rTTransf)) {
           continue;
         }
 

Core/include/Acts/Seeding/SeedFinderUtils.hpp

@@ -76,13 +76,15 @@ void transformCoordinates(Acts::SpacePointData& spacePointData,
 ///
 /// @tparam external_spacepoint_t The external spacepoint type.
 ///
+/// @param[in] spacePointData Auxiliary variables used by the seeding
 /// @param[in] config SeedFinder config containing the delegates to the strip measurement details.
 /// @param[in] sp Input space point used in the check.
 /// @param[in] spacepointPosition Spacepoint coordinates in xyz plane.
 /// @param[out] outputCoordinates The output vector to write to.
 /// @returns Boolean that says if spacepoint is compatible with being inside the detector element.
 template <typename external_spacepoint_t>
 bool xyzCoordinateCheck(
+    Acts::SpacePointData& spacePointData,
     const Acts::SeedFinderConfig<external_spacepoint_t>& config,
     const Acts::InternalSpacePoint<external_spacepoint_t>& sp,
     const double* spacepointPosition, double* outputCoordinates);

Core/include/Acts/Seeding/SeedFinderUtils.ipp

@@ -149,20 +149,28 @@ inline void transformCoordinates(Acts::SpacePointData& spacePointData,
 
 template <typename external_spacepoint_t>
 inline bool xyzCoordinateCheck(
+    Acts::SpacePointData& spacePointData,
     const Acts::SeedFinderConfig<external_spacepoint_t>& m_config,
     const Acts::InternalSpacePoint<external_spacepoint_t>& sp,
     const double* spacepointPosition, double* outputCoordinates) {
   // check the compatibility of SPs coordinates in xyz assuming the
   // Bottom-Middle direction with the strip measurement details
-  const float topHalfStripLength = m_config.getTopHalfStripLength(sp.sp());
-  const float bottomHalfStripLength =
-      m_config.getBottomHalfStripLength(sp.sp());
-  const Acts::Vector3 topStripDirection =
-      m_config.getTopStripDirection(sp.sp());
-  const Acts::Vector3 bottomStripDirection =
-      m_config.getBottomStripDirection(sp.sp());
-  const Acts::Vector3 stripCenterDistance =
-      m_config.getStripCenterDistance(sp.sp());
+  bool hasValueStored = spacePointData.hasDynamicVariable();
+  if (not hasValueStored) {
+    return false;
+  }
+
+  std::size_t index = sp.index();
+
+  const float& topHalfStripLength = spacePointData.getTopHalfStripLength(index);
+  const float& bottomHalfStripLength =
+      spacePointData.getBottomHalfStripLength(index);
+  const Acts::Vector3& topStripDirection =
+      spacePointData.getTopStripDirection(index);
+  const Acts::Vector3& bottomStripDirection =
+      spacePointData.getBottomStripDirection(index);
+  const Acts::Vector3& stripCenterDistance =
+      spacePointData.getStripCenterDistance(index);
 
   // cross product between top strip vector and spacepointPosition
   double d1[3] = {
@@ -211,8 +219,8 @@ inline bool xyzCoordinateCheck(
   // if arive here spacepointPosition is compatible with strip directions and
   // detector elements
 
-  const Acts::Vector3 topStripCenterPosition =
-      m_config.getTopStripCenterPosition(sp.sp());
+  const Acts::Vector3& topStripCenterPosition =
+      spacePointData.getTopStripCenterPosition(index);
 
   // spacepointPosition corected with respect to the top strip position and
   // direction and the distance between the strips

Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp

@@ -251,9 +251,31 @@ ActsExamples::ProcessCode ActsExamples::SeedingAlgorithm::execute(
   static thread_local SimSeedContainer seeds;
   seeds.clear();
   static thread_local decltype(m_seedFinder)::SeedingState state;
+  state.spacePointData.resize(
+      spacePointPtrs.size(),
+      m_cfg.seedFinderConfig.useDetailedDoubleMeasurementInfo);
 
-  state.spacePointData.clear();
-  state.spacePointData.resize(spacePointPtrs.size());
+  if (m_cfg.seedFinderConfig.useDetailedDoubleMeasurementInfo) {
+    for (std::size_t grid_glob_bin(0);
+         grid_glob_bin < spacePointsGrouping.grid().size(); ++grid_glob_bin) {
+      const auto& collection = spacePointsGrouping.grid().at(grid_glob_bin);
+      for (const auto& sp : collection) {
+        std::size_t index = sp->index();
+        state.spacePointData.setTopHalfStripLength(
+            index, m_cfg.seedFinderConfig.getTopHalfStripLength(sp->sp()));
+        state.spacePointData.setBottomHalfStripLength(
+            index, m_cfg.seedFinderConfig.getBottomHalfStripLength(sp->sp()));
+        state.spacePointData.setTopStripDirection(
+            index, m_cfg.seedFinderConfig.getTopStripDirection(sp->sp()));
+        state.spacePointData.setBottomStripDirection(
+            index, m_cfg.seedFinderConfig.getBottomStripDirection(sp->sp()));
+        state.spacePointData.setStripCenterDistance(
+            index, m_cfg.seedFinderConfig.getStripCenterDistance(sp->sp()));
+        state.spacePointData.setTopStripCenterPosition(
+            index, m_cfg.seedFinderConfig.getTopStripCenterPosition(sp->sp()));
+      }
+    }
+  }
 
   for (const auto [bottom, middle, top] : spacePointsGrouping) {
     m_seedFinder.createSeedsForGroup(