From 9161e015bdb09ed512727876b0431e566c1ae11d Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Tue, 14 Mar 2023 14:48:07 +0100
Subject: [PATCH 01/14] move quality

---
 CMakeLists.txt                                |  4 +--
 Core/include/Acts/Seeding/BinnedSPGroup.ipp   |  6 ++--
 .../Acts/Seeding/InternalSpacePoint.hpp       | 21 +++++-------
 Core/include/Acts/Seeding/SeedFilter.hpp      | 10 ++++--
 Core/include/Acts/Seeding/SeedFilter.ipp      | 34 ++++++++++++-------
 Core/include/Acts/Seeding/SeedFinder.hpp      |  9 +++++
 Core/include/Acts/Seeding/SeedFinder.ipp      |  5 +--
 .../Acts/Seeding/SeedFinderOrthogonal.ipp     | 14 +++++---
 .../TrackFinding/src/SeedingAlgorithm.cpp     |  3 ++
 9 files changed, 67 insertions(+), 39 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 618b0a85056..48d8a7ec612 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -53,14 +53,14 @@ option(ACTS_BUILD_FATRAS_GEANT4 "Build Geant4 Fatras package" OFF)
 # alignment related options
 option(ACTS_BUILD_ALIGNMENT "Build Alignment package" OFF)
 # examples related options
-option(ACTS_BUILD_EXAMPLES "Build standalone examples" OFF)
+option(ACTS_BUILD_EXAMPLES "Build standalone examples" ON)
 option(ACTS_BUILD_EXAMPLES_DD4HEP "Build DD4hep-based code in the examples" OFF)
 option(ACTS_BUILD_EXAMPLES_EDM4HEP "Build EDM4hep-based code in the examples" OFF)
 option(ACTS_BUILD_EXAMPLES_EXATRKX "Build the Exa.TrkX example code" OFF)
 option(ACTS_BUILD_EXAMPLES_GEANT4 "Build Geant4-based code in the examples" OFF)
 option(ACTS_BUILD_EXAMPLES_HEPMC3 "Build HepMC3-based code in the examples" OFF)
 option(ACTS_BUILD_EXAMPLES_PYTHIA8 "Build Pythia8-based code in the examples" OFF)
-option(ACTS_BUILD_EXAMPLES_PYTHON_BINDINGS "Build python bindings for the examples" OFF)
+option(ACTS_BUILD_EXAMPLES_PYTHON_BINDINGS "Build python bindings for the examples" ON)
 option(ACTS_BUILD_EXAMPLES_BINARIES "Build the examples binaries (deprecated)" OFF)
 option(ACTS_USE_SYSTEM_PYBIND11 "Use a system installation of pybind11" ${ACTS_USE_SYSTEM_LIBS} )
 option(ACTS_USE_EXAMPLES_TBB "Use Threading Building Blocks library in the examples" ON)
diff --git a/Core/include/Acts/Seeding/BinnedSPGroup.ipp b/Core/include/Acts/Seeding/BinnedSPGroup.ipp
index 13bbb818fe4..a6e2e33f038 100644
--- a/Core/include/Acts/Seeding/BinnedSPGroup.ipp
+++ b/Core/include/Acts/Seeding/BinnedSPGroup.ipp
@@ -1,3 +1,4 @@
+// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2023 CERN for the benefit of the Acts project
@@ -154,7 +155,8 @@ Acts::BinnedSPGroup<external_spacepoint_t>::BinnedSPGroup(
   // keep track of changed bins while sorting
   boost::container::flat_set<size_t> rBinsIndex;
 
-  for (spacepoint_iterator_t it = spBegin; it != spEnd; it++) {
+  std::size_t counter = 0;
+  for (spacepoint_iterator_t it = spBegin; it != spEnd; it++, ++counter) {
     if (*it == nullptr) {
       continue;
     }
@@ -177,7 +179,7 @@ Acts::BinnedSPGroup<external_spacepoint_t>::BinnedSPGroup(
       continue;
     }
 
-    auto isp = std::make_unique<InternalSpacePoint<external_spacepoint_t>>(
+    auto isp = std::make_unique<InternalSpacePoint<external_spacepoint_t>>(counter,
         sp, spPosition, options.beamPos, variance);
     // calculate r-Bin index and protect against overflow (underflow not
     // possible)
diff --git a/Core/include/Acts/Seeding/InternalSpacePoint.hpp b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
index 39f19647e22..a33f005281f 100644
--- a/Core/include/Acts/Seeding/InternalSpacePoint.hpp
+++ b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
@@ -23,7 +23,8 @@ class InternalSpacePoint {
 
  public:
   InternalSpacePoint() = delete;
-  InternalSpacePoint(const SpacePoint& sp, const Acts::Vector3& globalPos,
+  InternalSpacePoint(std::size_t index,
+		     const SpacePoint& sp, const Acts::Vector3& globalPos,
                      const Acts::Vector2& offsetXY,
                      const Acts::Vector2& variance);
 
@@ -33,6 +34,7 @@ class InternalSpacePoint {
   InternalSpacePoint<SpacePoint>& operator=(
       const InternalSpacePoint<SpacePoint>&) = delete;
 
+  std::size_t index() const { return m_index; }
   const float& x() const { return m_x; }
   const float& y() const { return m_y; }
   const float& z() const { return m_z; }
@@ -41,16 +43,11 @@ class InternalSpacePoint {
   const float& varianceR() const { return m_varianceR; }
   const float& varianceZ() const { return m_varianceZ; }
   const float& deltaR() const { return m_deltaR; }
-  const float& quality() const { return m_quality; }
   void setDeltaR(float deltaR) { m_deltaR = deltaR; }
-  void setQuality(float quality) {
-    if (quality >= m_quality) {
-      m_quality = quality;
-    }
-  }
   const SpacePoint& sp() const { return m_sp; }
 
  protected:
+  std::size_t m_index;
   float m_x;          // x-coordinate in beam system coordinates
   float m_y;          // y-coordinate in beam system coordinates
   float m_z;          // z-coordinate in beam system coordinetes
@@ -58,10 +55,6 @@ class InternalSpacePoint {
   float m_varianceR;  //
   float m_varianceZ;  //
   float m_deltaR;     //
-  float m_quality = -std::numeric_limits<
-      double>::infinity();  // Quality score of the seed the space point is used
-                            // for. Quality can be changed if the space point is
-                            // used for a better quality seed.
   const SpacePoint& m_sp;   // external space point
 };
 
@@ -71,9 +64,11 @@ class InternalSpacePoint {
 
 template <typename SpacePoint>
 inline InternalSpacePoint<SpacePoint>::InternalSpacePoint(
-    const SpacePoint& sp, const Acts::Vector3& globalPos,
+							  std::size_t index,
+							  const SpacePoint& sp, const Acts::Vector3& globalPos,
     const Acts::Vector2& offsetXY, const Acts::Vector2& variance)
-    : m_sp(sp) {
+  : m_index(index),
+    m_sp(sp) {
   m_x = globalPos.x() - offsetXY.x();
   m_y = globalPos.y() - offsetXY.y();
   m_z = globalPos.z();
diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index 070c191a679..c6d65b1552d 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -20,6 +20,10 @@
 #include <tuple>
 #include <vector>
 
+namespace Acts {
+  struct SpacePointInfo;
+}
+
 namespace Acts {
 struct SeedFilterState {
   // longitudinal impact parameter as defined by bottom and middle space point
@@ -55,7 +59,7 @@ class SeedFilter {
   /// @param impactParametersVec vector containing the impact parameters
   /// @param seedFilterState holds quantities used in seed filter
   /// @param candidates_collector container for the seed candidates
-  virtual void filterSeeds_2SpFixed(
+  virtual void filterSeeds_2SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
       InternalSpacePoint<external_spacepoint_t>& bottomSP,
       InternalSpacePoint<external_spacepoint_t>& middleSP,
       std::vector<InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
@@ -70,7 +74,7 @@ class SeedFilter {
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
   /// for all seeds with the same middle space point
-  virtual void filterSeeds_1SpFixed(
+  virtual void filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
       CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>&
           candidates_collector,
       std::size_t& numQualitySeeds,
@@ -82,7 +86,7 @@ class SeedFilter {
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
   /// for all seeds with the same middle space point
-  virtual void filterSeeds_1SpFixed(
+  virtual void filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
       std::vector<typename CandidatesForMiddleSp<
           InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
       std::size_t& numQualitySeeds,
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index 9f67a79f46d..73ecf8b6d62 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -1,3 +1,4 @@
+// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2018 CERN for the benefit of the Acts project
@@ -26,7 +27,7 @@ SeedFilter<external_spacepoint_t>::SeedFilter(
 // middle-spacepoint.
 // return vector must contain weight of each seed
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
+void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
     InternalSpacePoint<external_spacepoint_t>& bottomSP,
     InternalSpacePoint<external_spacepoint_t>& middleSP,
     std::vector<InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
@@ -178,8 +179,9 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
 
       // skip a bad quality seed if any of its constituents has a weight larger
       // than the seed weight
-      if (weight < bottomSP.quality() and weight < middleSP.quality() and
-          weight < topSpVec[topSPIndex]->quality()) {
+      if (weight < spacePointInfo[bottomSP.index()].quality and
+	  weight < spacePointInfo[middleSP.index()].quality and
+          weight < spacePointInfo[topSpVec[topSPIndex]->index()].quality) {
         continue;
       }
 
@@ -235,7 +237,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
 // after creating all seeds with a common middle space point, filter again
 
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
+void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
     CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>&
         candidates_collector,
     std::size_t& numQualitySeeds,
@@ -245,11 +247,11 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
   // this collection is alredy sorted
   // higher weights first
   auto extended_collection = candidates_collector.storage();
-  filterSeeds_1SpFixed(extended_collection, numQualitySeeds, outIt);
+  filterSeeds_1SpFixed(spacePointInfo, extended_collection, numQualitySeeds, outIt);
 }
 
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
+void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
     std::vector<typename CandidatesForMiddleSp<
         InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
     std::size_t& numQualitySeeds,
@@ -269,7 +271,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
   // ordering by weight by filterSeeds_2SpFixed means these are the lowest
   // weight seeds
   unsigned int numTotalSeeds = 0;
-  for (auto& [bottom, medium, top, bestSeedQuality, zOrigin, qualitySeed] :
+  for (const auto& [bottom, medium, top, bestSeedQuality, zOrigin, qualitySeed] :
        candidates) {
     // stop if we reach the maximum number of seeds
     if (numTotalSeeds >= maxSeeds) {
@@ -281,17 +283,23 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
       if (numQualitySeeds > 0 and not qualitySeed) {
         continue;
       }
-      if (bestSeedQuality < bottom->quality() and
-          bestSeedQuality < medium->quality() and
-          bestSeedQuality < top->quality()) {
+      if (bestSeedQuality < spacePointInfo[bottom->index()].quality and
+          bestSeedQuality < spacePointInfo[medium->index()].quality and
+          bestSeedQuality < spacePointInfo[top->index()].quality) {
         continue;
       }
     }
 
     // set quality of seed components
-    bottom->setQuality(bestSeedQuality);
-    medium->setQuality(bestSeedQuality);
-    top->setQuality(bestSeedQuality);
+    if (bestSeedQuality > spacePointInfo[bottom->index()].quality) {
+      spacePointInfo[bottom->index()].quality = bestSeedQuality;
+    }
+    if (bestSeedQuality > spacePointInfo[medium->index()].quality) {
+      spacePointInfo[medium->index()].quality = bestSeedQuality;
+    }
+    if (bestSeedQuality > spacePointInfo[top->index()].quality) {
+      spacePointInfo[top->index()].quality = bestSeedQuality;
+    }
 
     outIt = Seed<external_spacepoint_t>{bottom->sp(), medium->sp(), top->sp(),
                                         zOrigin, bestSeedQuality};
diff --git a/Core/include/Acts/Seeding/SeedFinder.hpp b/Core/include/Acts/Seeding/SeedFinder.hpp
index 45e61d92bd2..3e0a9fc9cfb 100644
--- a/Core/include/Acts/Seeding/SeedFinder.hpp
+++ b/Core/include/Acts/Seeding/SeedFinder.hpp
@@ -27,9 +27,15 @@
 #include <string>
 #include <utility>
 #include <vector>
+#include <limits>
 
 namespace Acts {
 
+  struct SpacePointInfo {  
+    float quality = -std::numeric_limits<float>::infinity();
+    float deltaR = 0;
+  };
+  
 template <typename external_spacepoint_t, typename platform_t = void*>
 class SeedFinder {
   ///////////////////////////////////////////////////////////////////
@@ -63,6 +69,9 @@ class SeedFinder {
         bottomNeighbours;
     boost::container::small_vector<Acts::Neighbour<external_spacepoint_t>, 9>
         topNeighbours;
+
+    // Adding space point info
+    std::vector<Acts::SpacePointInfo> spacePointInfo;
   };
 
   /// The only constructor. Requires a config object.
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index 099b07539f7..eeaa231957d 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -1,3 +1,4 @@
+// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2023 CERN for the benefit of the Acts project
@@ -160,7 +161,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
     // filter candidates
     filterCandidates(*spM.get(), options, seedFilterState, state);
 
-    m_config.seedFilter->filterSeeds_1SpFixed(
+    m_config.seedFilter->filterSeeds_1SpFixed(state.spacePointInfo,
         state.candidates_collector, seedFilterState.numQualitySeeds, outIt);
 
   }  // loop on mediums
@@ -591,7 +592,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
       continue;
     }
 
-    m_config.seedFilter->filterSeeds_2SpFixed(
+    m_config.seedFilter->filterSeeds_2SpFixed(state.spacePointInfo,
         *state.compatBottomSP[b], spM, state.topSpVec, state.curvatures,
         state.impactParameters, seedFilterState, state.candidates_collector);
   }  // loop on bottoms
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index 7ed59aa7002..4d45a39e104 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -1,3 +1,4 @@
+// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2022 CERN for the benefit of the Acts project
@@ -17,6 +18,8 @@
 #include <numeric>
 #include <type_traits>
 
+#include "Acts/Seeding/SeedFinder.hpp"
+
 namespace Acts {
 template <typename external_spacepoint_t>
 auto SeedFinderOrthogonal<external_spacepoint_t>::validTupleOrthoRangeLH(
@@ -431,8 +434,9 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
       }
     }
 
+    std::vector<Acts::SpacePointInfo> vec;
     if (!top_valid.empty()) {
-      m_config.seedFilter->filterSeeds_2SpFixed(
+      m_config.seedFilter->filterSeeds_2SpFixed(vec,
           *bottom[b], middle, top_valid, curvatures, impactParameters,
           seedFilterState, candidates_collector);
     }
@@ -593,7 +597,8 @@ void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
 
   // TODO: add seed confirmation
   SeedFilterState seedFilterState;
-
+  std::vector<Acts::SpacePointInfo> spacePointInfo;
+  
   /*
    * If we have candidates for increasing z tracks, we try to combine them.
    */
@@ -611,7 +616,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
   /*
    * Run a seed filter, just like in other seeding algorithms.
    */
-  m_config.seedFilter->filterSeeds_1SpFixed(candidates_collector,
+  m_config.seedFilter->filterSeeds_1SpFixed(spacePointInfo, candidates_collector,
                                             seedFilterState.numQualitySeeds,
                                             std::back_inserter(out_cont));
 }
@@ -670,10 +675,11 @@ void SeedFinderOrthogonal<external_spacepoint_t>::createSeeds(
    * point, and save it in a vector.
    */
   Acts::Extent rRangeSPExtent;
+  std::size_t counter = 0;
   std::vector<internal_sp_t *> internalSpacePoints;
   for (const external_spacepoint_t *p : spacePoints) {
     auto [position, variance] = extract_coordinates(p);
-    internalSpacePoints.push_back(new InternalSpacePoint<external_spacepoint_t>(
+    internalSpacePoints.push_back(new InternalSpacePoint<external_spacepoint_t>(counter++,
         *p, position, options.beamPos, variance));
     // store x,y,z values in extent
     rRangeSPExtent.extend(position);
diff --git a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
index 914bf26666c..fd6d00cf674 100644
--- a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
@@ -252,6 +252,9 @@ ActsExamples::ProcessCode ActsExamples::SeedingAlgorithm::execute(
   seeds.clear();
   static thread_local decltype(m_seedFinder)::SeedingState state;
 
+  state.spacePointInfo.clear();
+  state.spacePointInfo.resize(spacePointPtrs.size());
+  
   for (const auto [bottom, middle, top] : spacePointsGrouping) {
     m_seedFinder.createSeedsForGroup(
         m_cfg.seedFinderOptions, state, spacePointsGrouping.grid(),

From 3326cfc82219dca1dc2f35fd23c8a836e39dea7a Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Tue, 14 Mar 2023 15:07:14 +0100
Subject: [PATCH 02/14] move deltaR as well

---
 .../Acts/Seeding/InternalSpacePoint.hpp       | 24 +++++++++----------
 Core/include/Acts/Seeding/SeedFilter.ipp      |  8 +++----
 Core/include/Acts/Seeding/SeedFinder.ipp      |  4 ++--
 .../Acts/Seeding/SeedFinderOrthogonal.ipp     |  5 ++--
 Core/include/Acts/Seeding/SeedFinderUtils.hpp |  3 ++-
 Core/include/Acts/Seeding/SeedFinderUtils.ipp | 13 +++++-----
 6 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/Core/include/Acts/Seeding/InternalSpacePoint.hpp b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
index a33f005281f..1eaae2ec118 100644
--- a/Core/include/Acts/Seeding/InternalSpacePoint.hpp
+++ b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
@@ -42,8 +42,8 @@ class InternalSpacePoint {
   float phi() const { return atan2f(m_y, m_x); }
   const float& varianceR() const { return m_varianceR; }
   const float& varianceZ() const { return m_varianceZ; }
-  const float& deltaR() const { return m_deltaR; }
-  void setDeltaR(float deltaR) { m_deltaR = deltaR; }
+  // const float& deltaR() const { return m_deltaR; }
+  // void setDeltaR(float deltaR) { m_deltaR = deltaR; }
   const SpacePoint& sp() const { return m_sp; }
 
  protected:
@@ -54,7 +54,7 @@ class InternalSpacePoint {
   float m_r;          // radius       in beam system coordinates
   float m_varianceR;  //
   float m_varianceZ;  //
-  float m_deltaR;     //
+  //  float m_deltaR;     //
   const SpacePoint& m_sp;   // external space point
 };
 
@@ -68,15 +68,15 @@ inline InternalSpacePoint<SpacePoint>::InternalSpacePoint(
 							  const SpacePoint& sp, const Acts::Vector3& globalPos,
     const Acts::Vector2& offsetXY, const Acts::Vector2& variance)
   : m_index(index),
-    m_sp(sp) {
-  m_x = globalPos.x() - offsetXY.x();
-  m_y = globalPos.y() - offsetXY.y();
-  m_z = globalPos.z();
-  m_r = std::sqrt(m_x * m_x + m_y * m_y);
-  m_varianceR = variance.x();
-  m_varianceZ = variance.y();
-  m_deltaR = 0;
-}
+    m_x(globalPos.x() - offsetXY.x()),
+    m_y(globalPos.y() - offsetXY.y()),
+    m_z(globalPos.z()),
+    m_r(std::sqrt(m_x * m_x + m_y * m_y)),
+    m_varianceR(variance.x()),
+    m_varianceZ(variance.y()),
+    m_sp(sp)
+{}
+
 
 /////////////////////////////////////////////////////////////////////////////////
 // Copy constructor
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index 73ecf8b6d62..87ad32dc514 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -85,8 +85,8 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
     float upperLimitCurv = invHelixDiameter + m_cfg.deltaInvHelixDiameter;
     // use deltaR instead of top radius
     float currentTopR = m_cfg.useDeltaRorTopRadius
-                            ? topSpVec[topSPIndex]->deltaR()
-                            : topSpVec[topSPIndex]->radius();
+      ? spacePointInfo[topSpVec[topSPIndex]->index()].deltaR
+      : topSpVec[topSPIndex]->radius();
     float impact = impactParametersVec[topSPIndex];
 
     float weight = -(impact * m_cfg.impactWeightFactor);
@@ -99,8 +99,8 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
       }
 
       float otherTopR = m_cfg.useDeltaRorTopRadius
-                            ? topSpVec[compatibleTopSPIndex]->deltaR()
-                            : topSpVec[compatibleTopSPIndex]->radius();
+	? spacePointInfo[topSpVec[compatibleTopSPIndex]->index()].deltaR
+	: topSpVec[compatibleTopSPIndex]->radius();
 
       // curvature difference within limits?
       if (invHelixDiameterVec[compatibleTopSPIndex] < lowerLimitCurv) {
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index eeaa231957d..81ea6e6b234 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -309,10 +309,10 @@ void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
   state.linCircleBottom.reserve(numBottomSP);
   state.linCircleTop.reserve(numTopSP);
 
-  auto sorted_bottoms = transformCoordinates(state.compatBottomSP, spM, true,
+  auto sorted_bottoms = transformCoordinates(state.spacePointInfo, state.compatBottomSP, spM, true,
                                              state.linCircleBottom);
   auto sorted_tops =
-      transformCoordinates(state.compatTopSP, spM, false, state.linCircleTop);
+    transformCoordinates(state.spacePointInfo, state.compatTopSP, spM, false, state.linCircleTop);
 
   // Reserve enough space, in case current capacity is too little
   state.topSpVec.reserve(numTopSP);
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index 4d45a39e104..29d4a0a4cff 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -280,9 +280,10 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
   std::vector<LinCircle> linCircleTop;
   linCircleTop.reserve(top.size());
 
+  std::vector<Acts::SpacePointInfo> spacePointInfo;
   auto sorted_bottoms =
-      transformCoordinates(bottom, middle, true, linCircleBottom);
-  auto sorted_tops = transformCoordinates(top, middle, false, linCircleTop);
+    transformCoordinates(spacePointInfo, bottom, middle, true, linCircleBottom);
+  auto sorted_tops = transformCoordinates(spacePointInfo, top, middle, false, linCircleTop);
 
   std::vector<float> tanLM;
   std::vector<float> tanMT;
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.hpp b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
index f134ca98e84..ead9bc57bc1 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
@@ -58,12 +58,13 @@ LinCircle transformCoordinates(const external_spacepoint_t& sp,
 /// @returns Vector of sorted indexes for the vectors (vec and linCircleVec)
 template <typename external_spacepoint_t>
 std::vector<std::size_t> transformCoordinates(
+					      std::vector<Acts::SpacePointInfo>& spacePointInfo,
     std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     const InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     std::vector<LinCircle>& linCircleVec);
 
 template <typename external_spacepoint_t, typename callable_t>
-std::vector<std::size_t> transformCoordinates(
+std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
     std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
     bool bottom, std::vector<LinCircle>& linCircleVec,
     callable_t&& extractFunction);
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.ipp b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
index cd1aa71be67..0b9c54db540 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
@@ -1,3 +1,4 @@
+// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2019 CERN for the benefit of the Acts project
@@ -60,7 +61,7 @@ inline LinCircle transformCoordinates(const external_spacepoint_t& sp,
 }
 
 template <typename external_spacepoint_t>
-inline std::vector<std::size_t> transformCoordinates(
+inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
     std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     const InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     std::vector<LinCircle>& linCircleVec) {
@@ -72,12 +73,12 @@ inline std::vector<std::size_t> transformCoordinates(
     return output;
   };
 
-  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(
+  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(spacePointInfo,
       vec, spM, bottom, linCircleVec, extractFunction);
 }
 
 template <typename external_spacepoint_t, typename callable_t>
-inline std::vector<std::size_t> transformCoordinates(
+inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
     std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
     bool bottom, std::vector<LinCircle>& linCircleVec,
     callable_t&& extractFunction) {
@@ -90,8 +91,8 @@ inline std::vector<std::size_t> transformCoordinates(
 
   float cosPhiM = xM / rM;
   float sinPhiM = yM / rM;
-  for (auto sp : vec) {
-    auto [xSP, ySP, zSP, rSP, varianceRSP, varianceZSP] = extractFunction(*sp);
+  for (const auto* sp : vec) {
+    const auto [xSP, ySP, zSP, rSP, varianceRSP, varianceZSP] = extractFunction(*sp);
 
     float deltaX = xSP - xM;
     float deltaY = ySP - yM;
@@ -134,7 +135,7 @@ inline std::vector<std::size_t> transformCoordinates(
     l.r = sp->radius();
 
     linCircleVec.push_back(l);
-    sp->setDeltaR(std::sqrt((x * x) + (y * y) + (deltaZ * deltaZ)));
+    spacePointInfo[sp->index()].deltaR = std::sqrt((x * x) + (y * y) + (deltaZ * deltaZ));
   }
   // sort the SP in order of cotTheta
   std::sort(

From 06c6c326929f8f55fc0f69bdd1cac3747c56fac2 Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Tue, 14 Mar 2023 15:19:53 +0100
Subject: [PATCH 03/14] Move to const candidates

---
 Core/include/Acts/Seeding/IExperimentCuts.hpp      | 4 ++--
 Core/include/Acts/Seeding/SeedFilter.hpp           | 6 +++---
 Core/include/Acts/Seeding/SeedFilter.ipp           | 6 +++---
 Core/include/Acts/Seeding/SeedFinder.hpp           | 2 +-
 Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp | 2 +-
 Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp | 4 ++--
 Core/include/Acts/Seeding/SeedFinderUtils.hpp      | 4 ++--
 Core/include/Acts/Seeding/SeedFinderUtils.ipp      | 4 ++--
 8 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/Core/include/Acts/Seeding/IExperimentCuts.hpp b/Core/include/Acts/Seeding/IExperimentCuts.hpp
index d1e1ecd57e3..be03c6bd810 100644
--- a/Core/include/Acts/Seeding/IExperimentCuts.hpp
+++ b/Core/include/Acts/Seeding/IExperimentCuts.hpp
@@ -46,9 +46,9 @@ class IExperimentCuts {
   /// space point in a std::tuple format
   /// @return vector of seed candidates that pass the cut
   virtual std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<SpacePoint>>::value_type>
+      const InternalSpacePoint<SpacePoint>>::value_type>
   cutPerMiddleSP(std::vector<typename CandidatesForMiddleSp<
-                     InternalSpacePoint<SpacePoint>>::value_type>
+                     const InternalSpacePoint<SpacePoint>>::value_type>
                      seedCandidates) const = 0;
 };
 }  // namespace Acts
diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index c6d65b1552d..70ccf60ab62 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -66,7 +66,7 @@ class SeedFilter {
       const std::vector<float>& invHelixDiameterVec,
       const std::vector<float>& impactParametersVec,
       SeedFilterState& seedFilterState,
-      CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>&
+      CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
           candidates_collector) const;
 
   /// Filter seeds once all seeds for one middle space point have been created
@@ -75,7 +75,7 @@ class SeedFilter {
   /// @param outIt Output iterator for the seeds
   /// for all seeds with the same middle space point
   virtual void filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
-      CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>&
+      CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
           candidates_collector,
       std::size_t& numQualitySeeds,
       std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>> outIt)
@@ -88,7 +88,7 @@ class SeedFilter {
   /// for all seeds with the same middle space point
   virtual void filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
       std::vector<typename CandidatesForMiddleSp<
-          InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
+          const InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
       std::size_t& numQualitySeeds,
       std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>> outIt)
       const;
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index 87ad32dc514..dae5c478091 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -34,7 +34,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
     const std::vector<float>& invHelixDiameterVec,
     const std::vector<float>& impactParametersVec,
     SeedFilterState& seedFilterState,
-    CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>&
+    CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
         candidates_collector) const {
   // seed confirmation
   SeedConfirmationRangeConfig seedConfRange;
@@ -238,7 +238,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
 
 template <typename external_spacepoint_t>
 void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
-    CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>&
+    CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
         candidates_collector,
     std::size_t& numQualitySeeds,
     std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>> outIt)
@@ -253,7 +253,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::S
 template <typename external_spacepoint_t>
 void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
     std::vector<typename CandidatesForMiddleSp<
-        InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
+        const InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
     std::size_t& numQualitySeeds,
     std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>> outIt)
     const {
diff --git a/Core/include/Acts/Seeding/SeedFinder.hpp b/Core/include/Acts/Seeding/SeedFinder.hpp
index 3e0a9fc9cfb..22ede894b9f 100644
--- a/Core/include/Acts/Seeding/SeedFinder.hpp
+++ b/Core/include/Acts/Seeding/SeedFinder.hpp
@@ -61,7 +61,7 @@ class SeedFinder {
     std::vector<float> ptVec;
 
     // managing seed candidates for SpM
-    CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>
+    CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
         candidates_collector;
 
     // managing doublet candidates
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
index 478186311b8..f09f2d45776 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
@@ -216,7 +216,7 @@ class SeedFinderOrthogonal {
       const SeedFinderOptions &options, internal_sp_t &middle,
       std::vector<internal_sp_t *> &bottom, std::vector<internal_sp_t *> &top,
       SeedFilterState seedFilterState,
-      CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>
+      CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
           &candidates_collector) const;
 
   /**
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index 29d4a0a4cff..823154beb95 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -244,7 +244,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
     const SeedFinderOptions &options, internal_sp_t &middle,
     std::vector<internal_sp_t *> &bottom, std::vector<internal_sp_t *> &top,
     SeedFilterState seedFilterState,
-    CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>
+    CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
         &candidates_collector) const {
   float rM = middle.radius();
   float varianceRM = middle.varianceR();
@@ -473,7 +473,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
   std::size_t max_num_seeds_per_spm =
       m_config.seedFilter->getSeedFilterConfig().maxSeedsPerSpMConf;
 
-  CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>
+  CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
       candidates_collector;
   candidates_collector.setMaxElements(max_num_seeds_per_spm,
                                       max_num_quality_seeds_per_spm);
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.hpp b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
index ead9bc57bc1..6425616f3e1 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
@@ -59,13 +59,13 @@ LinCircle transformCoordinates(const external_spacepoint_t& sp,
 template <typename external_spacepoint_t>
 std::vector<std::size_t> transformCoordinates(
 					      std::vector<Acts::SpacePointInfo>& spacePointInfo,
-    std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
+    const std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     const InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     std::vector<LinCircle>& linCircleVec);
 
 template <typename external_spacepoint_t, typename callable_t>
 std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
-    std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
+    const std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
     bool bottom, std::vector<LinCircle>& linCircleVec,
     callable_t&& extractFunction);
 
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.ipp b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
index 0b9c54db540..89d7dd79bb4 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
@@ -62,7 +62,7 @@ inline LinCircle transformCoordinates(const external_spacepoint_t& sp,
 
 template <typename external_spacepoint_t>
 inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
-    std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
+    const std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     const InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     std::vector<LinCircle>& linCircleVec) {
   auto extractFunction =
@@ -79,7 +79,7 @@ inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePoin
 
 template <typename external_spacepoint_t, typename callable_t>
 inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
-    std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
+    const std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
     bool bottom, std::vector<LinCircle>& linCircleVec,
     callable_t&& extractFunction) {
   std::vector<std::size_t> indexes(vec.size());

From 49079fd82f5294e461981b0293effa2b75109479 Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Tue, 14 Mar 2023 15:26:36 +0100
Subject: [PATCH 04/14] other changes to constness

---
 Core/include/Acts/Seeding/SeedFilter.hpp           | 6 +++---
 Core/include/Acts/Seeding/SeedFilter.ipp           | 6 +++---
 Core/include/Acts/Seeding/SeedFinder.hpp           | 4 ++--
 Core/include/Acts/Seeding/SeedFinder.ipp           | 6 +++---
 Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp | 2 +-
 5 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index 70ccf60ab62..ca4c99ebfc2 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -60,9 +60,9 @@ class SeedFilter {
   /// @param seedFilterState holds quantities used in seed filter
   /// @param candidates_collector container for the seed candidates
   virtual void filterSeeds_2SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
-      InternalSpacePoint<external_spacepoint_t>& bottomSP,
-      InternalSpacePoint<external_spacepoint_t>& middleSP,
-      std::vector<InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
+      const InternalSpacePoint<external_spacepoint_t>& bottomSP,
+      const InternalSpacePoint<external_spacepoint_t>& middleSP,
+      const std::vector<const InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
       const std::vector<float>& invHelixDiameterVec,
       const std::vector<float>& impactParametersVec,
       SeedFilterState& seedFilterState,
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index dae5c478091..48caef00e67 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -28,9 +28,9 @@ SeedFilter<external_spacepoint_t>::SeedFilter(
 // return vector must contain weight of each seed
 template <typename external_spacepoint_t>
 void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
-    InternalSpacePoint<external_spacepoint_t>& bottomSP,
-    InternalSpacePoint<external_spacepoint_t>& middleSP,
-    std::vector<InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
+    const InternalSpacePoint<external_spacepoint_t>& bottomSP,
+    const InternalSpacePoint<external_spacepoint_t>& middleSP,
+    const std::vector<const InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
     const std::vector<float>& invHelixDiameterVec,
     const std::vector<float>& impactParametersVec,
     SeedFilterState& seedFilterState,
diff --git a/Core/include/Acts/Seeding/SeedFinder.hpp b/Core/include/Acts/Seeding/SeedFinder.hpp
index 22ede894b9f..f88d1e7ca46 100644
--- a/Core/include/Acts/Seeding/SeedFinder.hpp
+++ b/Core/include/Acts/Seeding/SeedFinder.hpp
@@ -54,7 +54,7 @@ class SeedFinder {
     std::vector<LinCircle> linCircleTop;
 
     // create vectors here to avoid reallocation in each loop
-    std::vector<InternalSpacePoint<external_spacepoint_t>*> topSpVec;
+    std::vector<const InternalSpacePoint<external_spacepoint_t>*> topSpVec;
     std::vector<float> curvatures;
     std::vector<float> impactParameters;
     std::vector<float> etaVec;
@@ -137,7 +137,7 @@ class SeedFinder {
   template <typename out_range_t>
   void getCompatibleDoublets(
       const Acts::SeedFinderOptions& options,
-      Acts::SpacePointGrid<external_spacepoint_t>& grid,
+      const Acts::SpacePointGrid<external_spacepoint_t>& grid,
       boost::container::small_vector<Acts::Neighbour<external_spacepoint_t>, 9>&
           otherSPs,
       const InternalSpacePoint<external_spacepoint_t>& mediumSP,
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index 81ea6e6b234..972716862bd 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -171,7 +171,7 @@ template <typename external_spacepoint_t, typename platform_t>
 template <typename out_range_t>
 void SeedFinder<external_spacepoint_t, platform_t>::getCompatibleDoublets(
     const Acts::SeedFinderOptions& options,
-    Acts::SpacePointGrid<external_spacepoint_t>& grid,
+    const Acts::SpacePointGrid<external_spacepoint_t>& grid,
     boost::container::small_vector<Neighbour<external_spacepoint_t>, 9>&
         otherSPsNeighbours,
     const InternalSpacePoint<external_spacepoint_t>& mediumSP,
@@ -189,7 +189,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::getCompatibleDoublets(
   const float ratio_yM_rM = yM / rM;
 
   for (auto& otherSPCol : otherSPsNeighbours) {
-    auto& otherSPs = grid.at(otherSPCol.index);
+    const auto& otherSPs = grid.at(otherSPCol.index);
     if (otherSPs.size() == 0) {
       continue;
     }
@@ -200,7 +200,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::getCompatibleDoublets(
     bool found = false;
 
     for (; min_itr != otherSPs.end(); ++min_itr) {
-      auto& otherSP = *min_itr;
+      const auto& otherSP = *min_itr;
       const float rO = otherSP->radius();
       float deltaR = sign * (rO - rM);
 
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index 823154beb95..84f720e0bec 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -268,7 +268,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
     }
   }
 
-  std::vector<internal_sp_t *> top_valid;
+  std::vector<const internal_sp_t *> top_valid;
   std::vector<float> curvatures;
   std::vector<float> impactParameters;
 

From 78b67f6cf9a8c706c59f1aa990798a6dfbf6f214 Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Tue, 14 Mar 2023 15:32:19 +0100
Subject: [PATCH 05/14] seeding runs on const inputs

---
 Core/include/Acts/Seeding/Neighbour.hpp  |  8 ++++----
 Core/include/Acts/Seeding/SeedFinder.hpp |  6 +++---
 Core/include/Acts/Seeding/SeedFinder.ipp | 10 +++++-----
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Core/include/Acts/Seeding/Neighbour.hpp b/Core/include/Acts/Seeding/Neighbour.hpp
index 669a417a29f..47e4e63f7da 100644
--- a/Core/include/Acts/Seeding/Neighbour.hpp
+++ b/Core/include/Acts/Seeding/Neighbour.hpp
@@ -43,24 +43,24 @@ struct Neighbour {
   /// @param grid The grid containing the space points
   /// @param idx The global index of the bin in the grid
   /// @param lowerBound The lower bound of the allowed space point
-  Neighbour(Acts::SpacePointGrid<external_spacepoint_t>& grid, std::size_t idx,
+  Neighbour(const Acts::SpacePointGrid<external_spacepoint_t>& grid, std::size_t idx,
             const float lowerBound);
 
   /// The global bin index on the grid
   std::size_t index;
   /// The iterator containing the position of the first space point in the valid
   /// radius range
-  typename Acts::SpacePointGrid<external_spacepoint_t>::value_type::iterator
+  typename Acts::SpacePointGrid<external_spacepoint_t>::value_type::const_iterator
       itr;
 };
 
 template <typename external_spacepoint_t>
 Neighbour<external_spacepoint_t>::Neighbour(
-    Acts::SpacePointGrid<external_spacepoint_t>& grid, std::size_t idx,
+    const Acts::SpacePointGrid<external_spacepoint_t>& grid, std::size_t idx,
     const float lowerBound)
     : index(idx) {
   /// Get the space points in this specific global bin
-  auto& collection = grid.at(idx);
+  const auto& collection = grid.at(idx);
   /// If there are no elements in the bin, we simply set the iterator to begin()
   /// and return. In this case begin() == end() so we run on nothing
   if (collection.size() == 0) {
diff --git a/Core/include/Acts/Seeding/SeedFinder.hpp b/Core/include/Acts/Seeding/SeedFinder.hpp
index f88d1e7ca46..64b53fec4d3 100644
--- a/Core/include/Acts/Seeding/SeedFinder.hpp
+++ b/Core/include/Acts/Seeding/SeedFinder.hpp
@@ -101,7 +101,7 @@ class SeedFinder {
   template <template <typename...> typename container_t, typename sp_range_t>
   void createSeedsForGroup(
       const Acts::SeedFinderOptions& options, SeedingState& state,
-      Acts::SpacePointGrid<external_spacepoint_t>& grid,
+      const Acts::SpacePointGrid<external_spacepoint_t>& grid,
       std::back_insert_iterator<container_t<Seed<external_spacepoint_t>>> outIt,
       const sp_range_t& bottomSPs, const std::size_t middleSPs,
       const sp_range_t& topSPs,
@@ -129,7 +129,7 @@ class SeedFinder {
   template <typename sp_range_t>
   std::vector<Seed<external_spacepoint_t>> createSeedsForGroup(
       const Acts::SeedFinderOptions& options,
-      Acts::SpacePointGrid<external_spacepoint_t>& grid,
+      const Acts::SpacePointGrid<external_spacepoint_t>& grid,
       const sp_range_t& bottomSPs, const std::size_t middleSPs,
       const sp_range_t& topSPs) const;
 
@@ -144,7 +144,7 @@ class SeedFinder {
       out_range_t& outVec, const float& deltaRMinSP, const float& deltaRMaxSP,
       bool isBottom) const;
 
-  void filterCandidates(InternalSpacePoint<external_spacepoint_t>& SpM,
+  void filterCandidates(const InternalSpacePoint<external_spacepoint_t>& SpM,
                         const Acts::SeedFinderOptions& options,
                         SeedFilterState& seedFilterState,
                         SeedingState& state) const;
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index 972716862bd..c0f24c4a3c9 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -40,7 +40,7 @@ template <typename external_spacepoint_t, typename platform_t>
 template <template <typename...> typename container_t, typename sp_range_t>
 void SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
     const Acts::SeedFinderOptions& options, SeedingState& state,
-    Acts::SpacePointGrid<external_spacepoint_t>& grid,
+    const Acts::SpacePointGrid<external_spacepoint_t>& grid,
     std::back_insert_iterator<container_t<Seed<external_spacepoint_t>>> outIt,
     const sp_range_t& bottomSPsIdx, const std::size_t middleSPsIdx,
     const sp_range_t& topSPsIdx,
@@ -65,7 +65,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
   }
 
   // Get the middle space point candidates
-  auto& middleSPs = grid.at(middleSPsIdx);
+  const auto& middleSPs = grid.at(middleSPsIdx);
 
   // neighbours
   // clear previous results
@@ -84,7 +84,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
         grid, idx, middleSPs.front()->radius() + m_config.deltaRMinTopSP);
   }
 
-  for (auto& spM : middleSPs) {
+  for (const auto& spM : middleSPs) {
     float rM = spM->radius();
     float zM = spM->z();
 
@@ -292,7 +292,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::getCompatibleDoublets(
 
 template <typename external_spacepoint_t, typename platform_t>
 void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
-    InternalSpacePoint<external_spacepoint_t>& spM,
+    const InternalSpacePoint<external_spacepoint_t>& spM,
     const Acts::SeedFinderOptions& options, SeedFilterState& seedFilterState,
     SeedingState& state) const {
   float rM = spM.radius();
@@ -603,7 +603,7 @@ template <typename sp_range_t>
 std::vector<Seed<external_spacepoint_t>>
 SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
     const Acts::SeedFinderOptions& options,
-    Acts::SpacePointGrid<external_spacepoint_t>& grid,
+    const Acts::SpacePointGrid<external_spacepoint_t>& grid,
     const sp_range_t& bottomSPs, const std::size_t middleSPs,
     const sp_range_t& topSPs) const {
   SeedingState state;

From f27c1fa9f35d57da319106b94d653701c91adcec Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@MacBook-Pro-di-Carlo-3.local>
Date: Thu, 16 Mar 2023 21:02:10 +0100
Subject: [PATCH 06/14] attempt

---
 .../include/Acts/EventData/SpacePointData.hpp | 98 +++++++++++++++++++
 Core/include/Acts/Seeding/SeedFilter.hpp      | 11 +--
 Core/include/Acts/Seeding/SeedFilter.ipp      | 36 +++----
 Core/include/Acts/Seeding/SeedFinder.hpp      |  8 +-
 Core/include/Acts/Seeding/SeedFinder.ipp      |  8 +-
 .../Acts/Seeding/SeedFinderOrthogonal.hpp     |  8 +-
 .../Acts/Seeding/SeedFinderOrthogonal.ipp     | 28 +++---
 Core/include/Acts/Seeding/SeedFinderUtils.hpp |  5 +-
 Core/include/Acts/Seeding/SeedFinderUtils.ipp |  8 +-
 .../TrackFinding/src/SeedingAlgorithm.cpp     |  4 +-
 10 files changed, 155 insertions(+), 59 deletions(-)
 create mode 100644 Core/include/Acts/EventData/SpacePointData.hpp

diff --git a/Core/include/Acts/EventData/SpacePointData.hpp b/Core/include/Acts/EventData/SpacePointData.hpp
new file mode 100644
index 00000000000..b5317c29922
--- /dev/null
+++ b/Core/include/Acts/EventData/SpacePointData.hpp
@@ -0,0 +1,98 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2023 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 http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include <limits>
+#include <vector>
+
+namespace Acts {
+
+  /// @class SpacePointData
+  /// This class contains auxiliary and mutable data associated to the
+  /// external space points provided by the customers
+  /// These variables are used internally by the seeding algorithm, that
+  /// reads and updates them
+  /// The variables collected here are also dynamic variables only present
+  /// for strip space points
+  class SpacePointData {    
+  public:
+    /// @brief Default constructor
+    SpacePointData() = default;
+
+    /// No copies
+    SpacePointData(const SpacePointData& other) = delete;
+    SpacePointData& operator=(const SpacePointData& other) = delete;
+
+    /// @brief Move operations
+    SpacePointData(SpacePointData&& other) noexcept = default;
+    SpacePointData& operator=(SpacePointData&& other) noexcept = default;
+
+    /// @brief Destructor
+    ~SpacePointData() = default;
+
+    /// @brief Getters
+    const float& quality(std::size_t idx) const;
+    const float& deltaR(std::size_t idx) const;
+    
+    /// @brief Setters
+    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);
+    
+    /// @brief clear vectors
+    void clear();
+    
+  private:
+    std::vector<float> m_quality {};
+    std::vector<float> m_deltaR {};
+  };
+  
+  inline const float&
+  SpacePointData::quality(std::size_t idx) const
+  { return m_quality[idx];  }
+
+  inline const float&
+  SpacePointData::deltaR(std::size_t idx) const
+  { return m_deltaR[idx]; }  
+
+  inline void
+  SpacePointData::setQuality(std::size_t idx, const float& value)
+  { m_quality[idx] = value; }
+
+  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)
+  {
+    m_quality.resize(n, -std::numeric_limits<float>::infinity());
+    m_deltaR.resize(n, 0.);
+  }
+
+  inline void
+  SpacePointData::clear()
+  {
+    m_quality.clear();
+    m_deltaR.clear();
+  }
+  
+}
diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index cee4df7ff60..7ff729a18e5 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -13,6 +13,7 @@
 #include "Acts/Seeding/InternalSeed.hpp"
 #include "Acts/Seeding/Seed.hpp"
 #include "Acts/Seeding/SeedFilterConfig.hpp"
+#include "Acts/EventData/SpacePointData.hpp"
 
 #include <memory>
 #include <mutex>
@@ -20,10 +21,6 @@
 #include <tuple>
 #include <vector>
 
-namespace Acts {
-  struct SpacePointInfo;
-}
-
 namespace Acts {
 struct SeedFilterState {
   // longitudinal impact parameter as defined by bottom and middle space point
@@ -63,7 +60,7 @@ class SeedFilter {
   /// @param impactParametersVec vector containing the impact parameters
   /// @param seedFilterState holds quantities used in seed filter
   /// @param candidates_collector container for the seed candidates
-  virtual void filterSeeds_2SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+  virtual void filterSeeds_2SpFixed(Acts::SpacePointData& spacePointData,
       const InternalSpacePoint<external_spacepoint_t>& bottomSP,
       const InternalSpacePoint<external_spacepoint_t>& middleSP,
       const std::vector<const InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
@@ -78,7 +75,7 @@ class SeedFilter {
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
   /// for all seeds with the same middle space point
-  virtual void filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+  virtual void filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
       CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
           candidates_collector,
       std::size_t& numQualitySeeds,
@@ -90,7 +87,7 @@ class SeedFilter {
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
   /// for all seeds with the same middle space point
-  virtual void filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+  virtual void filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
       std::vector<typename CandidatesForMiddleSp<
           const InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
       std::size_t& numQualitySeeds,
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index 48caef00e67..da0973733ae 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -27,7 +27,7 @@ SeedFilter<external_spacepoint_t>::SeedFilter(
 // middle-spacepoint.
 // return vector must contain weight of each seed
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(Acts::SpacePointData& spacePointData,
     const InternalSpacePoint<external_spacepoint_t>& bottomSP,
     const InternalSpacePoint<external_spacepoint_t>& middleSP,
     const std::vector<const InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
@@ -85,7 +85,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
     float upperLimitCurv = invHelixDiameter + m_cfg.deltaInvHelixDiameter;
     // use deltaR instead of top radius
     float currentTopR = m_cfg.useDeltaRorTopRadius
-      ? spacePointInfo[topSpVec[topSPIndex]->index()].deltaR
+      ? spacePointData.deltaR(topSpVec[topSPIndex]->index())
       : topSpVec[topSPIndex]->radius();
     float impact = impactParametersVec[topSPIndex];
 
@@ -99,7 +99,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
       }
 
       float otherTopR = m_cfg.useDeltaRorTopRadius
-	? spacePointInfo[topSpVec[compatibleTopSPIndex]->index()].deltaR
+	? spacePointData.deltaR(topSpVec[compatibleTopSPIndex]->index())
 	: topSpVec[compatibleTopSPIndex]->radius();
 
       // curvature difference within limits?
@@ -179,9 +179,9 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
 
       // skip a bad quality seed if any of its constituents has a weight larger
       // than the seed weight
-      if (weight < spacePointInfo[bottomSP.index()].quality and
-	  weight < spacePointInfo[middleSP.index()].quality and
-          weight < spacePointInfo[topSpVec[topSPIndex]->index()].quality) {
+      if (weight < spacePointData.quality(bottomSP.index()) and
+	  weight < spacePointData.quality(middleSP.index()) and
+          weight < spacePointData.quality(topSpVec[topSPIndex]->index())) {
         continue;
       }
 
@@ -237,7 +237,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(std::vector<Acts::S
 // after creating all seeds with a common middle space point, filter again
 
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
     CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
         candidates_collector,
     std::size_t& numQualitySeeds,
@@ -247,11 +247,11 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::S
   // this collection is alredy sorted
   // higher weights first
   auto extended_collection = candidates_collector.storage();
-  filterSeeds_1SpFixed(spacePointInfo, extended_collection, numQualitySeeds, outIt);
+  filterSeeds_1SpFixed(spacePointData, extended_collection, numQualitySeeds, outIt);
 }
 
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
     std::vector<typename CandidatesForMiddleSp<
         const InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
     std::size_t& numQualitySeeds,
@@ -283,22 +283,22 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(std::vector<Acts::S
       if (numQualitySeeds > 0 and not qualitySeed) {
         continue;
       }
-      if (bestSeedQuality < spacePointInfo[bottom->index()].quality and
-          bestSeedQuality < spacePointInfo[medium->index()].quality and
-          bestSeedQuality < spacePointInfo[top->index()].quality) {
+      if (bestSeedQuality < spacePointData.quality(bottom->index()) and
+          bestSeedQuality < spacePointData.quality(medium->index()) and
+          bestSeedQuality < spacePointData.quality(top->index())) {
         continue;
       }
     }
 
     // set quality of seed components
-    if (bestSeedQuality > spacePointInfo[bottom->index()].quality) {
-      spacePointInfo[bottom->index()].quality = bestSeedQuality;
+    if (bestSeedQuality > spacePointData.quality(bottom->index())) {
+      spacePointData.setQuality(bottom->index(), bestSeedQuality);
     }
-    if (bestSeedQuality > spacePointInfo[medium->index()].quality) {
-      spacePointInfo[medium->index()].quality = bestSeedQuality;
+    if (bestSeedQuality > spacePointData.quality(medium->index())) {
+      spacePointData.setQuality(medium->index(), bestSeedQuality);
     }
-    if (bestSeedQuality > spacePointInfo[top->index()].quality) {
-      spacePointInfo[top->index()].quality = bestSeedQuality;
+    if (bestSeedQuality > spacePointData.quality(top->index())) {
+      spacePointData.setQuality(top->index(), bestSeedQuality);
     }
 
     outIt = Seed<external_spacepoint_t>{bottom->sp(), medium->sp(), top->sp(),
diff --git a/Core/include/Acts/Seeding/SeedFinder.hpp b/Core/include/Acts/Seeding/SeedFinder.hpp
index 64b53fec4d3..1acb0a6ff42 100644
--- a/Core/include/Acts/Seeding/SeedFinder.hpp
+++ b/Core/include/Acts/Seeding/SeedFinder.hpp
@@ -18,6 +18,7 @@
 #include "Acts/Seeding/SeedFinderConfig.hpp"
 #include "Acts/Seeding/SeedFinderUtils.hpp"
 #include "Acts/Seeding/SpacePointGrid.hpp"
+#include "Acts/EventData/SpacePointData.hpp"
 
 #include <array>
 #include <list>
@@ -30,11 +31,6 @@
 #include <limits>
 
 namespace Acts {
-
-  struct SpacePointInfo {  
-    float quality = -std::numeric_limits<float>::infinity();
-    float deltaR = 0;
-  };
   
 template <typename external_spacepoint_t, typename platform_t = void*>
 class SeedFinder {
@@ -71,7 +67,7 @@ class SeedFinder {
         topNeighbours;
 
     // Adding space point info
-    std::vector<Acts::SpacePointInfo> spacePointInfo;
+    Acts::SpacePointData spacePointData;
   };
 
   /// The only constructor. Requires a config object.
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index 15cd2173f72..31252da65cb 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -164,7 +164,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
     // filter candidates
     filterCandidates(*spM.get(), options, seedFilterState, state);
 
-    m_config.seedFilter->filterSeeds_1SpFixed(state.spacePointInfo,
+    m_config.seedFilter->filterSeeds_1SpFixed(state.spacePointData,
         state.candidates_collector, seedFilterState.numQualitySeeds, outIt);
 
   }  // loop on mediums
@@ -312,10 +312,10 @@ void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
   state.linCircleBottom.reserve(numBottomSP);
   state.linCircleTop.reserve(numTopSP);
 
-  auto sorted_bottoms = transformCoordinates(state.spacePointInfo, state.compatBottomSP, spM, true,
+  auto sorted_bottoms = transformCoordinates(state.spacePointData, state.compatBottomSP, spM, true,
                                              state.linCircleBottom);
   auto sorted_tops =
-    transformCoordinates(state.spacePointInfo, state.compatTopSP, spM, false, state.linCircleTop);
+    transformCoordinates(state.spacePointData, state.compatTopSP, spM, false, state.linCircleTop);
 
   // Reserve enough space, in case current capacity is too little
   state.topSpVec.reserve(numTopSP);
@@ -608,7 +608,7 @@ void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
       continue;
     }
 
-    m_config.seedFilter->filterSeeds_2SpFixed(state.spacePointInfo,
+    m_config.seedFilter->filterSeeds_2SpFixed(state.spacePointData,
         *state.compatBottomSP[b], spM, state.topSpVec, state.curvatures,
         state.impactParameters, seedFilterState, state.candidates_collector);
   }  // loop on bottoms
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
index f09f2d45776..907e4496a8d 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
@@ -14,6 +14,7 @@
 #include "Acts/Seeding/SeedFinderConfig.hpp"
 #include "Acts/Seeding/SeedFinderOrthogonalConfig.hpp"
 #include "Acts/Utilities/KDTree.hpp"
+#include "Acts/EventData/SpacePointData.hpp"
 
 #include <array>
 #include <iostream>
@@ -217,7 +218,8 @@ class SeedFinderOrthogonal {
       std::vector<internal_sp_t *> &bottom, std::vector<internal_sp_t *> &top,
       SeedFilterState seedFilterState,
       CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
-          &candidates_collector) const;
+      &candidates_collector,
+      Acts::SpacePointData& spacePointData) const;
 
   /**
    * @brief Search for seeds starting from a given middle space point.
@@ -229,11 +231,13 @@ class SeedFinderOrthogonal {
    * @param tree The k-d tree to use for searching.
    * @param out_cont The container write output seeds to.
    * @param middle_p The middle spacepoint to find seeds for.
+   * @param spacePointData Aux data for the spacepoints
    */
   template <typename output_container_t>
   void processFromMiddleSP(const SeedFinderOptions &options, const tree_t &tree,
                            output_container_t &out_cont,
-                           const typename tree_t::pair_t &middle_p) const;
+                           const typename tree_t::pair_t &middle_p,
+			   Acts::SpacePointData& spacePointData) const;
 
   /**
    * @brief The configuration for the seeding algorithm.
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index 6da4f07b1b8..1747b503506 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -245,7 +245,8 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
     std::vector<internal_sp_t *> &bottom, std::vector<internal_sp_t *> &top,
     SeedFilterState seedFilterState,
     CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
-        &candidates_collector) const {
+    &candidates_collector,
+    Acts::SpacePointData& spacePointData) const {
   float rM = middle.radius();
   float varianceRM = middle.varianceR();
   float varianceZM = middle.varianceZ();
@@ -283,10 +284,9 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
   std::vector<LinCircle> linCircleTop;
   linCircleTop.reserve(top.size());
 
-  std::vector<Acts::SpacePointInfo> spacePointInfo;
   auto sorted_bottoms =
-    transformCoordinates(spacePointInfo, bottom, middle, true, linCircleBottom);
-  auto sorted_tops = transformCoordinates(spacePointInfo, top, middle, false, linCircleTop);
+    transformCoordinates(spacePointData, bottom, middle, true, linCircleBottom);
+  auto sorted_tops = transformCoordinates(spacePointData, top, middle, false, linCircleTop);
 
   std::vector<float> tanLM;
   std::vector<float> tanMT;
@@ -455,10 +455,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
       continue;
     }
 
-    // NEED FIXING
-    std::vector<Acts::SpacePointInfo> vec;
-    
-    m_config.seedFilter->filterSeeds_2SpFixed(vec,
+    m_config.seedFilter->filterSeeds_2SpFixed(spacePointData,
 					      *bottom[b], middle, top_valid, curvatures, impactParameters,
 					      seedFilterState, candidates_collector);
     
@@ -470,7 +467,8 @@ template <typename output_container_t>
 void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
     const SeedFinderOptions &options, const tree_t &tree,
     output_container_t &out_cont,
-    const typename tree_t::pair_t &middle_p) const {
+    const typename tree_t::pair_t &middle_p,
+    Acts::SpacePointData& spacePointData) const {
   using range_t = typename tree_t::range_t;
   internal_sp_t &middle = *middle_p.second;
 
@@ -619,26 +617,25 @@ void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
 
   // TODO: add seed confirmation
   SeedFilterState seedFilterState;
-  std::vector<Acts::SpacePointInfo> spacePointInfo;
   
   /*
    * If we have candidates for increasing z tracks, we try to combine them.
    */
   if (!bottom_lh_v.empty() && !top_lh_v.empty()) {
     filterCandidates(options, middle, bottom_lh_v, top_lh_v, seedFilterState,
-                     candidates_collector);
+                     candidates_collector, spacePointData);
   }
   /*
    * Try to combine candidates for decreasing z tracks.
    */
   if (!bottom_hl_v.empty() && !top_hl_v.empty()) {
     filterCandidates(options, middle, bottom_hl_v, top_hl_v, seedFilterState,
-                     candidates_collector);
+                     candidates_collector, spacePointData);
   }
   /*
    * Run a seed filter, just like in other seeding algorithms.
    */
-  m_config.seedFilter->filterSeeds_1SpFixed(spacePointInfo, candidates_collector,
+  m_config.seedFilter->filterSeeds_1SpFixed(spacePointData, candidates_collector,
                                             seedFilterState.numQualitySeeds,
                                             std::back_inserter(out_cont));
 }
@@ -699,6 +696,9 @@ void SeedFinderOrthogonal<external_spacepoint_t>::createSeeds(
   Acts::Extent rRangeSPExtent;
   std::size_t counter = 0;
   std::vector<internal_sp_t *> internalSpacePoints;
+  Acts::SpacePointData spacePointData;
+  spacePointData.resize(spacePoints.size());
+  
   for (const external_spacepoint_t *p : spacePoints) {
     auto [position, variance] = extract_coordinates(p);
     internalSpacePoints.push_back(new InternalSpacePoint<external_spacepoint_t>(counter++,
@@ -740,7 +740,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::createSeeds(
       }
     }
 
-    processFromMiddleSP(options, tree, out_cont, middle_p);
+    processFromMiddleSP(options, tree, out_cont, middle_p, spacePointData);
   }
 
   /*
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.hpp b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
index 6425616f3e1..eac7606343a 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
@@ -11,6 +11,7 @@
 #include "Acts/Seeding/InternalSeed.hpp"
 #include "Acts/Seeding/InternalSpacePoint.hpp"
 #include "Acts/Seeding/SeedFinderConfig.hpp"
+#include "Acts/EventData/SpacePointData.hpp"
 
 namespace Acts {
 /// @brief A partial description of a circle in u-v space.
@@ -58,13 +59,13 @@ LinCircle transformCoordinates(const external_spacepoint_t& sp,
 /// @returns Vector of sorted indexes for the vectors (vec and linCircleVec)
 template <typename external_spacepoint_t>
 std::vector<std::size_t> transformCoordinates(
-					      std::vector<Acts::SpacePointInfo>& spacePointInfo,
+    Acts::SpacePointData& spacePointData,
     const std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     const InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     std::vector<LinCircle>& linCircleVec);
 
 template <typename external_spacepoint_t, typename callable_t>
-std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& spacePointData,
     const std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
     bool bottom, std::vector<LinCircle>& linCircleVec,
     callable_t&& extractFunction);
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.ipp b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
index 89d7dd79bb4..3854c9c164d 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
@@ -61,7 +61,7 @@ inline LinCircle transformCoordinates(const external_spacepoint_t& sp,
 }
 
 template <typename external_spacepoint_t>
-inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+inline std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& spacePointData,
     const std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     const InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     std::vector<LinCircle>& linCircleVec) {
@@ -73,12 +73,12 @@ inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePoin
     return output;
   };
 
-  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(spacePointInfo,
+  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(spacePointData,
       vec, spM, bottom, linCircleVec, extractFunction);
 }
 
 template <typename external_spacepoint_t, typename callable_t>
-inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePointInfo>& spacePointInfo,
+inline std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& spacePointData,
     const std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
     bool bottom, std::vector<LinCircle>& linCircleVec,
     callable_t&& extractFunction) {
@@ -135,7 +135,7 @@ inline std::vector<std::size_t> transformCoordinates(std::vector<Acts::SpacePoin
     l.r = sp->radius();
 
     linCircleVec.push_back(l);
-    spacePointInfo[sp->index()].deltaR = std::sqrt((x * x) + (y * y) + (deltaZ * deltaZ));
+    spacePointData.setDeltaR(sp->index(), std::sqrt((x * x) + (y * y) + (deltaZ * deltaZ)));
   }
   // sort the SP in order of cotTheta
   std::sort(
diff --git a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
index fd6d00cf674..a5ba6b42169 100644
--- a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
@@ -252,8 +252,8 @@ ActsExamples::ProcessCode ActsExamples::SeedingAlgorithm::execute(
   seeds.clear();
   static thread_local decltype(m_seedFinder)::SeedingState state;
 
-  state.spacePointInfo.clear();
-  state.spacePointInfo.resize(spacePointPtrs.size());
+  state.spacePointData.clear();
+  state.spacePointData.resize(spacePointPtrs.size());
   
   for (const auto [bottom, middle, top] : spacePointsGrouping) {
     m_seedFinder.createSeedsForGroup(

From 3c99fc8654563808e070f114eb5e2ad0d8e004bb Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@MacBook-Pro-di-Carlo-3.local>
Date: Thu, 16 Mar 2023 21:59:55 +0100
Subject: [PATCH 07/14] tests

---
 Tests/UnitTests/Core/Seeding/ATLASCuts.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp b/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
index 03b16163e09..971b6a60f74 100644
--- a/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
+++ b/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
@@ -39,9 +39,9 @@ class ATLASCuts : public IExperimentCuts<SpacePoint> {
   /// space point in a std::tuple format
   /// @return vector of seeds that pass the cut
   std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<SpacePoint>>::value_type>
+      const InternalSpacePoint<SpacePoint>>::value_type>
   cutPerMiddleSP(std::vector<typename CandidatesForMiddleSp<
-                     InternalSpacePoint<SpacePoint>>::value_type>
+                     const InternalSpacePoint<SpacePoint>>::value_type>
                      seedCandidates) const override;
 };
 
@@ -70,13 +70,13 @@ bool ATLASCuts<SpacePoint>::singleSeedCut(
 
 template <typename SpacePoint>
 std::vector<
-    typename CandidatesForMiddleSp<InternalSpacePoint<SpacePoint>>::value_type>
+    typename CandidatesForMiddleSp<const InternalSpacePoint<SpacePoint>>::value_type>
 ATLASCuts<SpacePoint>::cutPerMiddleSP(
     std::vector<typename CandidatesForMiddleSp<
-        InternalSpacePoint<SpacePoint>>::value_type>
+        const InternalSpacePoint<SpacePoint>>::value_type>
         seedCandidates) const {
   std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<SpacePoint>>::value_type>
+      const InternalSpacePoint<SpacePoint>>::value_type>
       newSeedsVector;
   if (seedCandidates.size() <= 1) {
     return seedCandidates;

From 0eaa315c51b0a4652f91f1916a90d9d01509579a Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Fri, 17 Mar 2023 08:44:49 +0100
Subject: [PATCH 08/14] Propagate changes to SYCL and CUDA

---
 .../include/Acts/EventData/SpacePointData.hpp | 154 +++++++++---------
 Core/include/Acts/Seeding/BinnedSPGroup.ipp   |   5 +-
 .../Acts/Seeding/InternalSpacePoint.hpp       |  41 +++--
 Core/include/Acts/Seeding/Neighbour.hpp       |   8 +-
 Core/include/Acts/Seeding/SeedFilter.hpp      |  19 ++-
 Core/include/Acts/Seeding/SeedFilter.ipp      |  41 +++--
 Core/include/Acts/Seeding/SeedFinder.hpp      |   6 +-
 Core/include/Acts/Seeding/SeedFinder.ipp      |  22 +--
 .../Acts/Seeding/SeedFinderOrthogonal.hpp     |  10 +-
 .../Acts/Seeding/SeedFinderOrthogonal.ipp     |  45 +++--
 Core/include/Acts/Seeding/SeedFinderUtils.hpp |  13 +-
 Core/include/Acts/Seeding/SeedFinderUtils.ipp |  25 +--
 .../TrackFinding/src/SeedingAlgorithm.cpp     |   2 +-
 .../Acts/Plugins/Cuda/Seeding/SeedFinder.hpp  |   1 +
 .../Acts/Plugins/Cuda/Seeding/SeedFinder.ipp  |  15 +-
 .../Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp |   4 +-
 .../Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp |  12 +-
 .../Acts/Plugins/Sycl/Seeding/SeedFinder.hpp  |   1 +
 .../Acts/Plugins/Sycl/Seeding/SeedFinder.ipp  |  12 +-
 Tests/UnitTests/Core/Seeding/ATLASCuts.hpp    |   6 +-
 .../Plugins/Cuda/Seeding/ATLASCuts.hpp        |  14 +-
 .../Cuda/Seeding/SeedFinderCudaTest.cpp       |   8 +-
 .../Plugins/Cuda/Seeding2/TestHostCuts.cpp    |   6 +-
 .../Plugins/Cuda/Seeding2/TestHostCuts.hpp    |  11 +-
 .../UnitTests/Plugins/Cuda/Seeding2/main.cpp  |   7 +-
 .../Plugins/Sycl/Seeding/ATLASCuts.hpp        |  14 +-
 .../Sycl/Seeding/SeedFinderSyclTest.cpp       |   8 +-
 27 files changed, 267 insertions(+), 243 deletions(-)

diff --git a/Core/include/Acts/EventData/SpacePointData.hpp b/Core/include/Acts/EventData/SpacePointData.hpp
index d82c5488a4a..f8f40107483 100644
--- a/Core/include/Acts/EventData/SpacePointData.hpp
+++ b/Core/include/Acts/EventData/SpacePointData.hpp
@@ -13,90 +13,82 @@
 
 namespace Acts {
 
-  /// @class SpacePointData
-  /// This class contains auxiliary and mutable data associated to the
-  /// external space points provided by the customers
-  /// These variables are used internally by the seeding algorithm, that
-  /// reads and updates them
-  /// The variables collected here are also dynamic variables only present
-  /// for strip space points
-  class SpacePointData {    
-  public:
-    /// @brief Default constructor
-    SpacePointData() = default;
-
-    /// No copies
-    SpacePointData(const SpacePointData& other) = delete;
-    SpacePointData& operator=(const SpacePointData& other) = delete;
-
-    /// @brief Move operations
-    SpacePointData(SpacePointData&& other) noexcept = default;
-    SpacePointData& operator=(SpacePointData&& other) noexcept = default;
-
-    /// @brief Destructor
-    ~SpacePointData() = default;
-
-    /// @brief Getters
-    const float& quality(std::size_t idx) const;
-    const float& deltaR(std::size_t idx) const;
-    
-    /// @brief Setters
-    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);
-    
-    /// @brief clear vectors
-    void clear();
-    
-  private:
-    std::vector<float> m_quality {};
-    std::vector<float> m_deltaR {};
-  };
-  
-  inline const float&
-  SpacePointData::quality(std::size_t idx) const
-  { return m_quality[idx];  }
-
-  inline const float&
-  SpacePointData::deltaR(std::size_t idx) const
-  { return m_deltaR[idx]; }  
-
-  inline void
-  SpacePointData::setQuality(std::size_t idx, const float& value)
-  {
-    if (value > m_quality[idx]) {
-      m_quality[idx] = value;
-    }
-  }
+/// @class SpacePointData
+/// This class contains auxiliary and mutable data associated to the
+/// external space points provided by the customers
+/// These variables are used internally by the seeding algorithm, that
+/// reads and updates them
+/// The variables collected here are also dynamic variables only present
+/// for strip space points
+class SpacePointData {
+ public:
+  /// @brief Default constructor
+  SpacePointData() = default;
 
-  inline void
-  SpacePointData::setDeltaR(std::size_t idx, const float& value)
-  { m_deltaR[idx] = value; }
+  /// No copies
+  SpacePointData(const SpacePointData& other) = delete;
+  SpacePointData& operator=(const SpacePointData& other) = delete;
 
-  inline void
-  SpacePointData::reserve(std::size_t n)
-  {
-    m_quality.reserve(n);
-    m_deltaR.reserve(n);
-  }
+  /// @brief Move operations
+  SpacePointData(SpacePointData&& other) noexcept = default;
+  SpacePointData& operator=(SpacePointData&& other) noexcept = default;
 
-  inline void
-  SpacePointData::resize(std::size_t n)
-  {
-    m_quality.resize(n, -std::numeric_limits<float>::infinity());
-    m_deltaR.resize(n, 0.);
-  }
+  /// @brief Destructor
+  ~SpacePointData() = default;
+
+  /// @brief Getters
+  const float& quality(std::size_t idx) const;
+  const float& deltaR(std::size_t idx) const;
+
+  /// @brief Setters
+  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);
+
+  /// @brief clear vectors
+  void clear();
+
+ private:
+  std::vector<float> m_quality{};
+  std::vector<float> m_deltaR{};
+};
+
+inline const float& SpacePointData::quality(std::size_t idx) const {
+  return m_quality[idx];
+}
 
-  inline void
-  SpacePointData::clear()
-  {
-    m_quality.clear();
-    m_deltaR.clear();
+inline const float& SpacePointData::deltaR(std::size_t idx) const {
+  return m_deltaR[idx];
+}
+
+inline void SpacePointData::setQuality(std::size_t idx, const float& value) {
+  if (value > m_quality[idx]) {
+    m_quality[idx] = value;
   }
-  
 }
+
+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) {
+  m_quality.resize(n, -std::numeric_limits<float>::infinity());
+  m_deltaR.resize(n, 0.);
+}
+
+inline void SpacePointData::clear() {
+  m_quality.clear();
+  m_deltaR.clear();
+}
+
+}  // namespace Acts
diff --git a/Core/include/Acts/Seeding/BinnedSPGroup.ipp b/Core/include/Acts/Seeding/BinnedSPGroup.ipp
index a6e2e33f038..e8c99c0ac0a 100644
--- a/Core/include/Acts/Seeding/BinnedSPGroup.ipp
+++ b/Core/include/Acts/Seeding/BinnedSPGroup.ipp
@@ -1,4 +1,3 @@
-// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2023 CERN for the benefit of the Acts project
@@ -179,8 +178,8 @@ Acts::BinnedSPGroup<external_spacepoint_t>::BinnedSPGroup(
       continue;
     }
 
-    auto isp = std::make_unique<InternalSpacePoint<external_spacepoint_t>>(counter,
-        sp, spPosition, options.beamPos, variance);
+    auto isp = std::make_unique<InternalSpacePoint<external_spacepoint_t>>(
+        counter, sp, spPosition, options.beamPos, variance);
     // calculate r-Bin index and protect against overflow (underflow not
     // possible)
     size_t rIndex = static_cast<size_t>(isp->radius() / config.binSizeR);
diff --git a/Core/include/Acts/Seeding/InternalSpacePoint.hpp b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
index 4f1d6668281..10aa06d4c0f 100644
--- a/Core/include/Acts/Seeding/InternalSpacePoint.hpp
+++ b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -23,8 +23,8 @@ class InternalSpacePoint {
 
  public:
   InternalSpacePoint() = delete;
-  InternalSpacePoint(std::size_t index,
-		     const SpacePoint& sp, const Acts::Vector3& globalPos,
+  InternalSpacePoint(std::size_t index, const SpacePoint& sp,
+                     const Acts::Vector3& globalPos,
                      const Acts::Vector2& offsetXY,
                      const Acts::Vector2& variance);
 
@@ -46,13 +46,13 @@ class InternalSpacePoint {
 
  protected:
   std::size_t m_index;
-  float m_x;          // x-coordinate in beam system coordinates
-  float m_y;          // y-coordinate in beam system coordinates
-  float m_z;          // z-coordinate in beam system coordinetes
-  float m_r;          // radius       in beam system coordinates
-  float m_varianceR;  //
-  float m_varianceZ;  //
-  const SpacePoint& m_sp;   // external space point
+  float m_x;               // x-coordinate in beam system coordinates
+  float m_y;               // y-coordinate in beam system coordinates
+  float m_z;               // z-coordinate in beam system coordinetes
+  float m_r;               // radius       in beam system coordinates
+  float m_varianceR;       //
+  float m_varianceZ;       //
+  const SpacePoint& m_sp;  // external space point
 };
 
 /////////////////////////////////////////////////////////////////////////////////
@@ -61,19 +61,16 @@ class InternalSpacePoint {
 
 template <typename SpacePoint>
 inline InternalSpacePoint<SpacePoint>::InternalSpacePoint(
-							  std::size_t index,
-							  const SpacePoint& sp, const Acts::Vector3& globalPos,
+    std::size_t index, const SpacePoint& sp, const Acts::Vector3& globalPos,
     const Acts::Vector2& offsetXY, const Acts::Vector2& variance)
-  : m_index(index),
-    m_x(globalPos.x() - offsetXY.x()),
-    m_y(globalPos.y() - offsetXY.y()),
-    m_z(globalPos.z()),
-    m_r(std::sqrt(m_x * m_x + m_y * m_y)),
-    m_varianceR(variance.x()),
-    m_varianceZ(variance.y()),
-    m_sp(sp)
-{}
-
+    : m_index(index),
+      m_x(globalPos.x() - offsetXY.x()),
+      m_y(globalPos.y() - offsetXY.y()),
+      m_z(globalPos.z()),
+      m_r(std::sqrt(m_x * m_x + m_y * m_y)),
+      m_varianceR(variance.x()),
+      m_varianceZ(variance.y()),
+      m_sp(sp) {}
 
 /////////////////////////////////////////////////////////////////////////////////
 // Copy constructor
diff --git a/Core/include/Acts/Seeding/Neighbour.hpp b/Core/include/Acts/Seeding/Neighbour.hpp
index 47e4e63f7da..8dc6b0bfe5f 100644
--- a/Core/include/Acts/Seeding/Neighbour.hpp
+++ b/Core/include/Acts/Seeding/Neighbour.hpp
@@ -43,15 +43,15 @@ struct Neighbour {
   /// @param grid The grid containing the space points
   /// @param idx The global index of the bin in the grid
   /// @param lowerBound The lower bound of the allowed space point
-  Neighbour(const Acts::SpacePointGrid<external_spacepoint_t>& grid, std::size_t idx,
-            const float lowerBound);
+  Neighbour(const Acts::SpacePointGrid<external_spacepoint_t>& grid,
+            std::size_t idx, const float lowerBound);
 
   /// The global bin index on the grid
   std::size_t index;
   /// The iterator containing the position of the first space point in the valid
   /// radius range
-  typename Acts::SpacePointGrid<external_spacepoint_t>::value_type::const_iterator
-      itr;
+  typename Acts::SpacePointGrid<
+      external_spacepoint_t>::value_type::const_iterator itr;
 };
 
 template <typename external_spacepoint_t>
diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index 7ff729a18e5..0b4a7d209e7 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018-2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -8,12 +8,12 @@
 
 #pragma once
 
+#include "Acts/EventData/SpacePointData.hpp"
 #include "Acts/Seeding/CandidatesForMiddleSp.hpp"
 #include "Acts/Seeding/IExperimentCuts.hpp"
 #include "Acts/Seeding/InternalSeed.hpp"
 #include "Acts/Seeding/Seed.hpp"
 #include "Acts/Seeding/SeedFilterConfig.hpp"
-#include "Acts/EventData/SpacePointData.hpp"
 
 #include <memory>
 #include <mutex>
@@ -60,10 +60,12 @@ class SeedFilter {
   /// @param impactParametersVec vector containing the impact parameters
   /// @param seedFilterState holds quantities used in seed filter
   /// @param candidates_collector container for the seed candidates
-  virtual void filterSeeds_2SpFixed(Acts::SpacePointData& spacePointData,
+  virtual void filterSeeds_2SpFixed(
+      Acts::SpacePointData& spacePointData,
       const InternalSpacePoint<external_spacepoint_t>& bottomSP,
       const InternalSpacePoint<external_spacepoint_t>& middleSP,
-      const std::vector<const InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
+      const std::vector<const InternalSpacePoint<external_spacepoint_t>*>&
+          topSpVec,
       const std::vector<float>& invHelixDiameterVec,
       const std::vector<float>& impactParametersVec,
       SeedFilterState& seedFilterState,
@@ -75,7 +77,8 @@ class SeedFilter {
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
   /// for all seeds with the same middle space point
-  virtual void filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
+  virtual void filterSeeds_1SpFixed(
+      Acts::SpacePointData& spacePointData,
       CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
           candidates_collector,
       std::size_t& numQualitySeeds,
@@ -87,9 +90,11 @@ class SeedFilter {
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
   /// for all seeds with the same middle space point
-  virtual void filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
+  virtual void filterSeeds_1SpFixed(
+      Acts::SpacePointData& spacePointData,
       std::vector<typename CandidatesForMiddleSp<
-          const InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
+          const InternalSpacePoint<external_spacepoint_t>>::value_type>&
+          candidates,
       std::size_t& numQualitySeeds,
       std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>> outIt)
       const;
diff --git a/Core/include/Acts/Seeding/SeedFilter.ipp b/Core/include/Acts/Seeding/SeedFilter.ipp
index ae9fc3e9d43..717c97831c1 100644
--- a/Core/include/Acts/Seeding/SeedFilter.ipp
+++ b/Core/include/Acts/Seeding/SeedFilter.ipp
@@ -1,7 +1,6 @@
-// -*- C++ -*-
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -27,10 +26,12 @@ SeedFilter<external_spacepoint_t>::SeedFilter(
 // middle-spacepoint.
 // return vector must contain weight of each seed
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(Acts::SpacePointData& spacePointData,
+void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
+    Acts::SpacePointData& spacePointData,
     const InternalSpacePoint<external_spacepoint_t>& bottomSP,
     const InternalSpacePoint<external_spacepoint_t>& middleSP,
-    const std::vector<const InternalSpacePoint<external_spacepoint_t>*>& topSpVec,
+    const std::vector<const InternalSpacePoint<external_spacepoint_t>*>&
+        topSpVec,
     const std::vector<float>& invHelixDiameterVec,
     const std::vector<float>& impactParametersVec,
     SeedFilterState& seedFilterState,
@@ -84,9 +85,10 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(Acts::SpacePointDat
     float lowerLimitCurv = invHelixDiameter - m_cfg.deltaInvHelixDiameter;
     float upperLimitCurv = invHelixDiameter + m_cfg.deltaInvHelixDiameter;
     // use deltaR instead of top radius
-    float currentTopR = m_cfg.useDeltaRorTopRadius
-      ? spacePointData.deltaR(topSpVec[topSPIndex]->index())
-      : topSpVec[topSPIndex]->radius();
+    float currentTopR =
+        m_cfg.useDeltaRorTopRadius
+            ? spacePointData.deltaR(topSpVec[topSPIndex]->index())
+            : topSpVec[topSPIndex]->radius();
     float impact = impactParametersVec[topSPIndex];
 
     float weight = -(impact * m_cfg.impactWeightFactor);
@@ -98,9 +100,10 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(Acts::SpacePointDat
         continue;
       }
 
-      float otherTopR = m_cfg.useDeltaRorTopRadius
-	? spacePointData.deltaR(topSpVec[compatibleTopSPIndex]->index())
-	: topSpVec[compatibleTopSPIndex]->radius();
+      float otherTopR =
+          m_cfg.useDeltaRorTopRadius
+              ? spacePointData.deltaR(topSpVec[compatibleTopSPIndex]->index())
+              : topSpVec[compatibleTopSPIndex]->radius();
 
       // curvature difference within limits?
       if (invHelixDiameterVec[compatibleTopSPIndex] < lowerLimitCurv) {
@@ -180,7 +183,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(Acts::SpacePointDat
       // skip a bad quality seed if any of its constituents has a weight larger
       // than the seed weight
       if (weight < spacePointData.quality(bottomSP.index()) and
-	  weight < spacePointData.quality(middleSP.index()) and
+          weight < spacePointData.quality(middleSP.index()) and
           weight < spacePointData.quality(topSpVec[topSPIndex]->index())) {
         continue;
       }
@@ -237,7 +240,8 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(Acts::SpacePointDat
 // after creating all seeds with a common middle space point, filter again
 
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
+void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
+    Acts::SpacePointData& spacePointData,
     CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&
         candidates_collector,
     std::size_t& numQualitySeeds,
@@ -247,13 +251,16 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(Acts::SpacePointDat
   // this collection is alredy sorted
   // higher weights first
   auto extended_collection = candidates_collector.storage();
-  filterSeeds_1SpFixed(spacePointData, extended_collection, numQualitySeeds, outIt);
+  filterSeeds_1SpFixed(spacePointData, extended_collection, numQualitySeeds,
+                       outIt);
 }
 
 template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(Acts::SpacePointData& spacePointData,
+void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
+    Acts::SpacePointData& spacePointData,
     std::vector<typename CandidatesForMiddleSp<
-        const InternalSpacePoint<external_spacepoint_t>>::value_type>& candidates,
+        const InternalSpacePoint<external_spacepoint_t>>::value_type>&
+        candidates,
     std::size_t& numQualitySeeds,
     std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>> outIt)
     const {
@@ -271,8 +278,8 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(Acts::SpacePointDat
   // ordering by weight by filterSeeds_2SpFixed means these are the lowest
   // weight seeds
   unsigned int numTotalSeeds = 0;
-  for (const auto& [bottom, medium, top, bestSeedQuality, zOrigin, qualitySeed] :
-       candidates) {
+  for (const auto& [bottom, medium, top, bestSeedQuality, zOrigin,
+                    qualitySeed] : candidates) {
     // stop if we reach the maximum number of seeds
     if (numTotalSeeds >= maxSeeds) {
       break;
diff --git a/Core/include/Acts/Seeding/SeedFinder.hpp b/Core/include/Acts/Seeding/SeedFinder.hpp
index 56ea2c86140..3b9dcd09e95 100644
--- a/Core/include/Acts/Seeding/SeedFinder.hpp
+++ b/Core/include/Acts/Seeding/SeedFinder.hpp
@@ -9,6 +9,7 @@
 #pragma once
 
 #include "Acts/Definitions/Units.hpp"
+#include "Acts/EventData/SpacePointData.hpp"
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Seeding/CandidatesForMiddleSp.hpp"
 #include "Acts/Seeding/InternalSeed.hpp"
@@ -18,9 +19,9 @@
 #include "Acts/Seeding/SeedFinderConfig.hpp"
 #include "Acts/Seeding/SeedFinderUtils.hpp"
 #include "Acts/Seeding/SpacePointGrid.hpp"
-#include "Acts/EventData/SpacePointData.hpp"
 
 #include <array>
+#include <limits>
 #include <list>
 #include <map>
 #include <memory>
@@ -28,10 +29,9 @@
 #include <string>
 #include <utility>
 #include <vector>
-#include <limits>
 
 namespace Acts {
-  
+
 template <typename external_spacepoint_t, typename platform_t = void*>
 class SeedFinder {
   ///////////////////////////////////////////////////////////////////
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index 4ad60c7d8bf..5d93c119d70 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -1,4 +1,3 @@
-// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2023 CERN for the benefit of the Acts project
@@ -164,8 +163,9 @@ void SeedFinder<external_spacepoint_t, platform_t>::createSeedsForGroup(
     // filter candidates
     filterCandidates(*spM.get(), options, seedFilterState, state);
 
-    m_config.seedFilter->filterSeeds_1SpFixed(state.spacePointData,
-        state.candidates_collector, seedFilterState.numQualitySeeds, outIt);
+    m_config.seedFilter->filterSeeds_1SpFixed(
+        state.spacePointData, state.candidates_collector,
+        seedFilterState.numQualitySeeds, outIt);
 
   }  // loop on mediums
 }
@@ -312,10 +312,11 @@ void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
   state.linCircleBottom.reserve(numBottomSP);
   state.linCircleTop.reserve(numTopSP);
 
-  auto sorted_bottoms = transformCoordinates(state.spacePointData, state.compatBottomSP, spM, true,
-                                             state.linCircleBottom);
-  auto sorted_tops =
-    transformCoordinates(state.spacePointData, state.compatTopSP, spM, false, state.linCircleTop);
+  auto sorted_bottoms =
+      transformCoordinates(state.spacePointData, state.compatBottomSP, spM,
+                           true, state.linCircleBottom);
+  auto sorted_tops = transformCoordinates(
+      state.spacePointData, state.compatTopSP, spM, false, state.linCircleTop);
 
   // Reserve enough space, in case current capacity is too little
   state.topSpVec.reserve(numTopSP);
@@ -604,9 +605,10 @@ void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
       continue;
     }
 
-    m_config.seedFilter->filterSeeds_2SpFixed(state.spacePointData,
-        *state.compatBottomSP[b], spM, state.topSpVec, state.curvatures,
-        state.impactParameters, seedFilterState, state.candidates_collector);
+    m_config.seedFilter->filterSeeds_2SpFixed(
+        state.spacePointData, *state.compatBottomSP[b], spM, state.topSpVec,
+        state.curvatures, state.impactParameters, seedFilterState,
+        state.candidates_collector);
   }  // loop on bottoms
 }
 
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
index 907e4496a8d..70396a9b754 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -8,13 +8,13 @@
 
 #pragma once
 
+#include "Acts/EventData/SpacePointData.hpp"
 #include "Acts/Seeding/InternalSeed.hpp"
 #include "Acts/Seeding/InternalSpacePoint.hpp"
 #include "Acts/Seeding/SeedFilter.hpp"
 #include "Acts/Seeding/SeedFinderConfig.hpp"
 #include "Acts/Seeding/SeedFinderOrthogonalConfig.hpp"
 #include "Acts/Utilities/KDTree.hpp"
-#include "Acts/EventData/SpacePointData.hpp"
 
 #include <array>
 #include <iostream>
@@ -218,8 +218,8 @@ class SeedFinderOrthogonal {
       std::vector<internal_sp_t *> &bottom, std::vector<internal_sp_t *> &top,
       SeedFilterState seedFilterState,
       CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
-      &candidates_collector,
-      Acts::SpacePointData& spacePointData) const;
+          &candidates_collector,
+      Acts::SpacePointData &spacePointData) const;
 
   /**
    * @brief Search for seeds starting from a given middle space point.
@@ -237,7 +237,7 @@ class SeedFinderOrthogonal {
   void processFromMiddleSP(const SeedFinderOptions &options, const tree_t &tree,
                            output_container_t &out_cont,
                            const typename tree_t::pair_t &middle_p,
-			   Acts::SpacePointData& spacePointData) const;
+                           Acts::SpacePointData &spacePointData) const;
 
   /**
    * @brief The configuration for the seeding algorithm.
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
index e0ccfd79b49..00e06f68c18 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp
@@ -1,7 +1,6 @@
-// -*- C++ -*-
 // This file is part of the Acts project.
 //
-// Copyright (C) 2022 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -9,6 +8,7 @@
 
 #include "Acts/Geometry/Extent.hpp"
 #include "Acts/Seeding/SeedFilter.hpp"
+#include "Acts/Seeding/SeedFinder.hpp"
 #include "Acts/Seeding/SeedFinderOrthogonalConfig.hpp"
 #include "Acts/Seeding/SeedFinderUtils.hpp"
 #include "Acts/Utilities/BinningType.hpp"
@@ -18,8 +18,6 @@
 #include <numeric>
 #include <type_traits>
 
-#include "Acts/Seeding/SeedFinder.hpp"
-
 namespace Acts {
 template <typename external_spacepoint_t>
 auto SeedFinderOrthogonal<external_spacepoint_t>::validTupleOrthoRangeLH(
@@ -245,8 +243,8 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
     std::vector<internal_sp_t *> &bottom, std::vector<internal_sp_t *> &top,
     SeedFilterState seedFilterState,
     CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>
-    &candidates_collector,
-    Acts::SpacePointData& spacePointData) const {
+        &candidates_collector,
+    Acts::SpacePointData &spacePointData) const {
   float rM = middle.radius();
   float varianceRM = middle.varianceR();
   float varianceZM = middle.varianceZ();
@@ -284,9 +282,10 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
   std::vector<LinCircle> linCircleTop;
   linCircleTop.reserve(top.size());
 
-  auto sorted_bottoms =
-    transformCoordinates(spacePointData, bottom, middle, true, linCircleBottom);
-  auto sorted_tops = transformCoordinates(spacePointData, top, middle, false, linCircleTop);
+  auto sorted_bottoms = transformCoordinates(spacePointData, bottom, middle,
+                                             true, linCircleBottom);
+  auto sorted_tops =
+      transformCoordinates(spacePointData, top, middle, false, linCircleTop);
 
   std::vector<float> tanLM;
   std::vector<float> tanMT;
@@ -457,10 +456,10 @@ void SeedFinderOrthogonal<external_spacepoint_t>::filterCandidates(
       continue;
     }
 
-    m_config.seedFilter->filterSeeds_2SpFixed(spacePointData,
-					      *bottom[b], middle, top_valid, curvatures, impactParameters,
-					      seedFilterState, candidates_collector);
-    
+    m_config.seedFilter->filterSeeds_2SpFixed(
+        spacePointData, *bottom[b], middle, top_valid, curvatures,
+        impactParameters, seedFilterState, candidates_collector);
+
   }  // loop on bottoms
 }
 
@@ -468,9 +467,8 @@ template <typename external_spacepoint_t>
 template <typename output_container_t>
 void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
     const SeedFinderOptions &options, const tree_t &tree,
-    output_container_t &out_cont,
-    const typename tree_t::pair_t &middle_p,
-    Acts::SpacePointData& spacePointData) const {
+    output_container_t &out_cont, const typename tree_t::pair_t &middle_p,
+    Acts::SpacePointData &spacePointData) const {
   using range_t = typename tree_t::range_t;
   internal_sp_t &middle = *middle_p.second;
 
@@ -619,7 +617,7 @@ void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
 
   // TODO: add seed confirmation
   SeedFilterState seedFilterState;
-  
+
   /*
    * If we have candidates for increasing z tracks, we try to combine them.
    */
@@ -637,9 +635,9 @@ void SeedFinderOrthogonal<external_spacepoint_t>::processFromMiddleSP(
   /*
    * Run a seed filter, just like in other seeding algorithms.
    */
-  m_config.seedFilter->filterSeeds_1SpFixed(spacePointData, candidates_collector,
-                                            seedFilterState.numQualitySeeds,
-                                            std::back_inserter(out_cont));
+  m_config.seedFilter->filterSeeds_1SpFixed(
+      spacePointData, candidates_collector, seedFilterState.numQualitySeeds,
+      std::back_inserter(out_cont));
 }
 
 template <typename external_spacepoint_t>
@@ -700,11 +698,11 @@ void SeedFinderOrthogonal<external_spacepoint_t>::createSeeds(
   std::vector<internal_sp_t *> internalSpacePoints;
   Acts::SpacePointData spacePointData;
   spacePointData.resize(spacePoints.size());
-  
+
   for (const external_spacepoint_t *p : spacePoints) {
     auto [position, variance] = extract_coordinates(p);
-    internalSpacePoints.push_back(new InternalSpacePoint<external_spacepoint_t>(counter++,
-        *p, position, options.beamPos, variance));
+    internalSpacePoints.push_back(new InternalSpacePoint<external_spacepoint_t>(
+        counter++, *p, position, options.beamPos, variance));
     // store x,y,z values in extent
     rRangeSPExtent.extend(position);
   }
@@ -742,7 +740,6 @@ void SeedFinderOrthogonal<external_spacepoint_t>::createSeeds(
       }
     }
 
-
     // remove all middle SPs outside phi and z region of interest
     if (middle.z() > m_config.zMax || middle.z() < m_config.zMin) {
       continue;
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.hpp b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
index eac7606343a..1e9e45baa92 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -8,10 +8,10 @@
 
 #pragma once
 
+#include "Acts/EventData/SpacePointData.hpp"
 #include "Acts/Seeding/InternalSeed.hpp"
 #include "Acts/Seeding/InternalSpacePoint.hpp"
 #include "Acts/Seeding/SeedFinderConfig.hpp"
-#include "Acts/EventData/SpacePointData.hpp"
 
 namespace Acts {
 /// @brief A partial description of a circle in u-v space.
@@ -65,10 +65,11 @@ std::vector<std::size_t> transformCoordinates(
     std::vector<LinCircle>& linCircleVec);
 
 template <typename external_spacepoint_t, typename callable_t>
-std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& spacePointData,
-    const std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
-    bool bottom, std::vector<LinCircle>& linCircleVec,
-    callable_t&& extractFunction);
+std::vector<std::size_t> transformCoordinates(
+    Acts::SpacePointData& spacePointData,
+    const std::vector<external_spacepoint_t*>& vec,
+    const external_spacepoint_t& spM, bool bottom,
+    std::vector<LinCircle>& linCircleVec, callable_t&& extractFunction);
 
 /// @brief Check the compatibility of spacepoint coordinates in xyz assuming the Bottom-Middle direction with the strip meassument details
 ///
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.ipp b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
index 3854c9c164d..9abc91f3fc2 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
@@ -1,7 +1,6 @@
-// -*- C++ -*-
 // This file is part of the Acts project.
 //
-// Copyright (C) 2019 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -61,7 +60,8 @@ inline LinCircle transformCoordinates(const external_spacepoint_t& sp,
 }
 
 template <typename external_spacepoint_t>
-inline std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& spacePointData,
+inline std::vector<std::size_t> transformCoordinates(
+    Acts::SpacePointData& spacePointData,
     const std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     const InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     std::vector<LinCircle>& linCircleVec) {
@@ -73,15 +73,16 @@ inline std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& space
     return output;
   };
 
-  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(spacePointData,
-      vec, spM, bottom, linCircleVec, extractFunction);
+  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(
+      spacePointData, vec, spM, bottom, linCircleVec, extractFunction);
 }
 
 template <typename external_spacepoint_t, typename callable_t>
-inline std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& spacePointData,
-    const std::vector<external_spacepoint_t*>& vec, const external_spacepoint_t& spM,
-    bool bottom, std::vector<LinCircle>& linCircleVec,
-    callable_t&& extractFunction) {
+inline std::vector<std::size_t> transformCoordinates(
+    Acts::SpacePointData& spacePointData,
+    const std::vector<external_spacepoint_t*>& vec,
+    const external_spacepoint_t& spM, bool bottom,
+    std::vector<LinCircle>& linCircleVec, callable_t&& extractFunction) {
   std::vector<std::size_t> indexes(vec.size());
   for (unsigned int i(0); i < indexes.size(); i++) {
     indexes[i] = i;
@@ -92,7 +93,8 @@ inline std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& space
   float cosPhiM = xM / rM;
   float sinPhiM = yM / rM;
   for (const auto* sp : vec) {
-    const auto [xSP, ySP, zSP, rSP, varianceRSP, varianceZSP] = extractFunction(*sp);
+    const auto [xSP, ySP, zSP, rSP, varianceRSP, varianceZSP] =
+        extractFunction(*sp);
 
     float deltaX = xSP - xM;
     float deltaY = ySP - yM;
@@ -135,7 +137,8 @@ inline std::vector<std::size_t> transformCoordinates(Acts::SpacePointData& space
     l.r = sp->radius();
 
     linCircleVec.push_back(l);
-    spacePointData.setDeltaR(sp->index(), std::sqrt((x * x) + (y * y) + (deltaZ * deltaZ)));
+    spacePointData.setDeltaR(sp->index(),
+                             std::sqrt((x * x) + (y * y) + (deltaZ * deltaZ)));
   }
   // sort the SP in order of cotTheta
   std::sort(
diff --git a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
index a5ba6b42169..5311a1e50e4 100644
--- a/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
+++ b/Examples/Algorithms/TrackFinding/src/SeedingAlgorithm.cpp
@@ -254,7 +254,7 @@ ActsExamples::ProcessCode ActsExamples::SeedingAlgorithm::execute(
 
   state.spacePointData.clear();
   state.spacePointData.resize(spacePointPtrs.size());
-  
+
   for (const auto [bottom, middle, top] : spacePointsGrouping) {
     m_seedFinder.createSeedsForGroup(
         m_cfg.seedFinderOptions, state, spacePointsGrouping.grid(),
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp
index 3402dfd3bef..7735593f0ce 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.hpp
@@ -57,6 +57,7 @@ class SeedFinder<external_spacepoint_t, Acts::Cuda> {
   /// @return vector in which all found seeds for this group are stored.
   template <typename sp_range_t>
   std::vector<Seed<external_spacepoint_t> > createSeedsForGroup(
+      Acts::SpacePointData& spacePointData,
       Acts::SpacePointGrid<external_spacepoint_t>& grid,
       const sp_range_t& bottomSPs, const std::size_t middleSPs,
       const sp_range_t& topSPs) const;
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
index 3e30d074335..8f5446e9bfe 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding/SeedFinder.ipp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -47,6 +47,7 @@ template <typename external_spacepoint_t>
 template <typename sp_range_t>
 std::vector<Seed<external_spacepoint_t>>
 SeedFinder<external_spacepoint_t, Acts::Cuda>::createSeedsForGroup(
+    Acts::SpacePointData& spacePointData,
     Acts::SpacePointGrid<external_spacepoint_t>& grid,
     const sp_range_t& bottomSPs, const std::size_t middleSPs,
     const sp_range_t& topSPs) const {
@@ -274,7 +275,7 @@ SeedFinder<external_spacepoint_t, Acts::Cuda>::createSeedsForGroup(
     if (i_m > 0) {
       const auto m_experimentCuts = m_config.seedFilter->getExperimentCuts();
       std::vector<typename CandidatesForMiddleSp<
-          InternalSpacePoint<external_spacepoint_t>>::value_type>
+          const InternalSpacePoint<external_spacepoint_t>>::value_type>
           candidates;
 
       for (int i = 0; i < *nTrplPerSpM_cpu.get(i_m - 1); i++) {
@@ -304,12 +305,12 @@ SeedFinder<external_spacepoint_t, Acts::Cuda>::createSeedsForGroup(
                                 false);
       }
 
-      std::sort(
-          candidates.begin(), candidates.end(),
-          CandidatesForMiddleSp<
-              InternalSpacePoint<external_spacepoint_t>>::descendingByQuality);
+      std::sort(candidates.begin(), candidates.end(),
+                CandidatesForMiddleSp<const InternalSpacePoint<
+                    external_spacepoint_t>>::descendingByQuality);
       std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
-      m_config.seedFilter->filterSeeds_1SpFixed(candidates, numQualitySeeds,
+      m_config.seedFilter->filterSeeds_1SpFixed(spacePointData, candidates,
+                                                numQualitySeeds,
                                                 std::back_inserter(outputVec));
     }
   }
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp
index f94d91e1647..fc3b7f484c5 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -12,6 +12,7 @@
 #include "Acts/Plugins/Cuda/Seeding2/TripletFilterConfig.hpp"
 
 // Acts include(s).
+#include "Acts/EventData/SpacePointData.hpp"
 #include "Acts/Seeding/Seed.hpp"
 #include "Acts/Seeding/SeedFilterConfig.hpp"
 #include "Acts/Seeding/SeedFinderConfig.hpp"
@@ -58,6 +59,7 @@ class SeedFinder {
   /// @return vector in which all found seeds for this group are stored.
   template <typename sp_range_t>
   std::vector<Seed<external_spacepoint_t> > createSeedsForGroup(
+      Acts::SpacePointData& spacePointData,
       Acts::SpacePointGrid<external_spacepoint_t>& grid,
       const sp_range_t& bottomSPs, const std::size_t middleSPs,
       const sp_range_t& topSPs) const;
diff --git a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
index 738ed80cdbe..9568e3209d6 100644
--- a/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
+++ b/Plugins/Cuda/include/Acts/Plugins/Cuda/Seeding2/SeedFinder.ipp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -81,6 +81,7 @@ template <typename external_spacepoint_t>
 template <typename sp_range_t>
 std::vector<Seed<external_spacepoint_t>>
 SeedFinder<external_spacepoint_t>::createSeedsForGroup(
+    Acts::SpacePointData& spacePointData,
     Acts::SpacePointGrid<external_spacepoint_t>& grid,
     const sp_range_t& bottomSPs, const std::size_t middleSPs,
     const sp_range_t& topSPs) const {
@@ -213,7 +214,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
   auto triplet_end = tripletCandidates.end();
   for (; triplet_itr != triplet_end; ++triplet_itr, ++middleIndex) {
     std::vector<typename CandidatesForMiddleSp<
-        InternalSpacePoint<external_spacepoint_t>>::value_type>
+        const InternalSpacePoint<external_spacepoint_t>>::value_type>
         candidates;
 
     auto& middleSP = *(middleSPVec[middleIndex]);
@@ -227,11 +228,12 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
     }
     std::sort(
         candidates.begin(), candidates.end(),
-        CandidatesForMiddleSp<
-            InternalSpacePoint<external_spacepoint_t>>::descendingByQuality);
+        CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>::
+            descendingByQuality);
     std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
     m_commonConfig.seedFilter->filterSeeds_1SpFixed(
-        candidates, numQualitySeeds, std::back_inserter(outputVec));
+        spacePointData, candidates, numQualitySeeds,
+        std::back_inserter(outputVec));
   }
 
   // Free up all allocated device memory.
diff --git a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp
index 88c33d9c5de..bc82b98d49f 100644
--- a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp
+++ b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.hpp
@@ -49,6 +49,7 @@ class SeedFinder {
   /// @return vector in which all found seeds for this group are stored.
   template <typename sp_range_t>
   std::vector<Seed<external_spacepoint_t>> createSeedsForGroup(
+      Acts::SpacePointData& spacePointData,
       Acts::SpacePointGrid<external_spacepoint_t>& grid,
       const sp_range_t& bottomSPs, const std::size_t middleSPs,
       const sp_range_t& topSPs) const;
diff --git a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp
index 095ba51af9f..7d1c9bab29e 100644
--- a/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp
+++ b/Plugins/Sycl/include/Acts/Plugins/Sycl/Seeding/SeedFinder.ipp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020-2021 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -63,6 +63,7 @@ template <typename external_spacepoint_t>
 template <typename sp_range_t>
 std::vector<Acts::Seed<external_spacepoint_t>>
 SeedFinder<external_spacepoint_t>::createSeedsForGroup(
+    Acts::SpacePointData& spacePointData,
     Acts::SpacePointGrid<external_spacepoint_t>& grid,
     const sp_range_t& bottomSPs, const std::size_t middleSPs,
     const sp_range_t& topSPs) const {
@@ -129,7 +130,7 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
   // Iterate through seeds returned by the SYCL algorithm and perform the last
   // step of filtering for fixed middle SP.
   std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<external_spacepoint_t>>::value_type>
+      const InternalSpacePoint<external_spacepoint_t>>::value_type>
       candidates;
 
   for (size_t mi = 0; mi < seeds.size(); ++mi) {
@@ -144,10 +145,11 @@ SeedFinder<external_spacepoint_t>::createSeedsForGroup(
     }
     std::sort(
         candidates.begin(), candidates.end(),
-        CandidatesForMiddleSp<
-            InternalSpacePoint<external_spacepoint_t>>::descendingByQuality);
+        CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>::
+            descendingByQuality);
     std::size_t numQualitySeeds = 0;  // not used but needs to be fixed
-    m_config.seedFilter->filterSeeds_1SpFixed(candidates, numQualitySeeds,
+    m_config.seedFilter->filterSeeds_1SpFixed(spacePointData, candidates,
+                                              numQualitySeeds,
                                               std::back_inserter(outputVec));
   }
   return outputVec;
diff --git a/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp b/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
index 971b6a60f74..7a70f37b224 100644
--- a/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
+++ b/Tests/UnitTests/Core/Seeding/ATLASCuts.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -69,8 +69,8 @@ bool ATLASCuts<SpacePoint>::singleSeedCut(
 }
 
 template <typename SpacePoint>
-std::vector<
-    typename CandidatesForMiddleSp<const InternalSpacePoint<SpacePoint>>::value_type>
+std::vector<typename CandidatesForMiddleSp<
+    const InternalSpacePoint<SpacePoint>>::value_type>
 ATLASCuts<SpacePoint>::cutPerMiddleSP(
     std::vector<typename CandidatesForMiddleSp<
         const InternalSpacePoint<SpacePoint>>::value_type>
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp b/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp
index bf3ad385065..36912534604 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding/ATLASCuts.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -38,9 +38,9 @@ class ATLASCuts : public IExperimentCuts<SpacePoint> {
   /// space point in a std::tuple format
   /// @return vector of seed candidates that pass the cut
   std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<SpacePoint>>::value_type>
+      const InternalSpacePoint<SpacePoint>>::value_type>
   cutPerMiddleSP(std::vector<typename CandidatesForMiddleSp<
-                     InternalSpacePoint<SpacePoint>>::value_type>
+                     const InternalSpacePoint<SpacePoint>>::value_type>
                      seedCandidates) const override;
 };
 
@@ -68,14 +68,14 @@ bool ATLASCuts<SpacePoint>::singleSeedCut(
 }
 
 template <typename SpacePoint>
-std::vector<
-    typename CandidatesForMiddleSp<InternalSpacePoint<SpacePoint>>::value_type>
+std::vector<typename CandidatesForMiddleSp<
+    const InternalSpacePoint<SpacePoint>>::value_type>
 ATLASCuts<SpacePoint>::cutPerMiddleSP(
     std::vector<typename CandidatesForMiddleSp<
-        InternalSpacePoint<SpacePoint>>::value_type>
+        const InternalSpacePoint<SpacePoint>>::value_type>
         seedCandidates) const {
   std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<SpacePoint>>::value_type>
+      const InternalSpacePoint<SpacePoint>>::value_type>
       newSeedsVector;
   if (seedCandidates.size() <= 1) {
     return seedCandidates;
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding/SeedFinderCudaTest.cpp b/Tests/UnitTests/Plugins/Cuda/Seeding/SeedFinderCudaTest.cpp
index 88168da4bb3..aa4f59237f2 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding/SeedFinderCudaTest.cpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding/SeedFinderCudaTest.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -270,6 +270,7 @@ int main(int argc, char** argv) {
 
   if (do_cpu) {
     decltype(seedFinder_cpu)::SeedingState state;
+    state.spacePointData.resize(spVec.size());
     for (; groupIt != spGroup.end(); ++groupIt) {
       const auto [bottom, middle, top] = *groupIt;
       seedFinder_cpu.createSeedsForGroup(
@@ -299,10 +300,13 @@ int main(int argc, char** argv) {
   std::vector<std::vector<Acts::Seed<SpacePoint>>> seedVector_cuda;
   groupIt = Acts::BinnedSPGroupIterator<SpacePoint>(spGroup, skip);
 
+  Acts::SpacePointData spacePointData;
+  spacePointData.resize(spVec.size());
+
   for (; groupIt != spGroup.end(); ++groupIt) {
     const auto [bottom, middle, top] = *groupIt;
     seedVector_cuda.push_back(seedFinder_cuda.createSeedsForGroup(
-        spGroup.grid(), bottom, middle, top));
+        spacePointData, spGroup.grid(), bottom, middle, top));
     group_count++;
     if (allgroup == false) {
       if (group_count >= nGroupToIterate)
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp b/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp
index 63c1eb3a56d..fddf549488d 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.cpp
@@ -31,13 +31,13 @@ bool TestHostCuts::singleSeedCut(
 }
 
 std::vector<typename Acts::CandidatesForMiddleSp<
-    Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
+    const Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
 TestHostCuts::cutPerMiddleSP(
     std::vector<typename Acts::CandidatesForMiddleSp<
-        Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
+        const Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
         seedCandidates) const {
   std::vector<typename Acts::CandidatesForMiddleSp<
-      Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
+      const Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
       newSeedsVector;
   if (seedCandidates.size() <= 1) {
     return seedCandidates;
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.hpp b/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.hpp
index 07676c27fdf..a64b20c0fa6 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.hpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding2/TestHostCuts.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -42,9 +42,10 @@ class TestHostCuts : public Acts::IExperimentCuts<TestSpacePoint> {
   /// space point in a std::tuple format
   /// @return vector of seed candidates that pass the cut
   std::vector<typename Acts::CandidatesForMiddleSp<
-      Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
-  cutPerMiddleSP(std::vector<typename Acts::CandidatesForMiddleSp<
-                     Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
-                     seedCandidates) const final override;
+      const Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
+  cutPerMiddleSP(
+      std::vector<typename Acts::CandidatesForMiddleSp<
+          const Acts::InternalSpacePoint<TestSpacePoint>>::value_type>
+          seedCandidates) const final override;
 
 };  // struct TestHostCuts
diff --git a/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp b/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp
index ecc210afccd..794e71ba26b 100644
--- a/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp
+++ b/Tests/UnitTests/Plugins/Cuda/Seeding2/main.cpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -19,6 +19,7 @@
 #include "Acts/Plugins/Cuda/Utilities/MemoryManager.hpp"
 
 // Acts include(s).
+#include "Acts/EventData/SpacePointData.hpp"
 #include "Acts/Seeding/BinFinder.hpp"
 #include "Acts/Seeding/BinnedSPGroup.hpp"
 #include "Acts/Seeding/SeedFilterConfig.hpp"
@@ -208,6 +209,8 @@ int main(int argc, char* argv[]) {
   auto start_device = std::chrono::system_clock::now();
   // Create the result object.
   std::vector<std::vector<Acts::Seed<TestSpacePoint>>> seeds_device;
+  Acts::SpacePointData spacePointData;
+  spacePointData.resize(spView.size());
 
   // Perform the seed finding.
   for (std::size_t i = 0; i < cmdl.groupsToIterate; ++i) {
@@ -217,7 +220,7 @@ int main(int argc, char* argv[]) {
     }
     auto [bottom, middle, top] = *spGroup_itr;
     seeds_device.push_back(seedFinder_device.createSeedsForGroup(
-        spGroup.grid(), bottom, middle, top));
+        spacePointData, spGroup.grid(), bottom, middle, top));
   }
 
   // Record the finish time.
diff --git a/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp b/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp
index 621675b5c3c..42080827c46 100644
--- a/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp
+++ b/Tests/UnitTests/Plugins/Sycl/Seeding/ATLASCuts.hpp
@@ -1,6 +1,6 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2018 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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
@@ -38,9 +38,9 @@ class ATLASCuts : public IExperimentCuts<SpacePoint> {
   /// space point in a std::tuple format
   /// @return vector of seed candidates that pass the cut
   std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<SpacePoint>>::value_type>
+      const InternalSpacePoint<SpacePoint>>::value_type>
   cutPerMiddleSP(std::vector<typename CandidatesForMiddleSp<
-                     InternalSpacePoint<SpacePoint>>::value_type>
+                     const InternalSpacePoint<SpacePoint>>::value_type>
                      seedCandidates) const override;
 };
 
@@ -68,14 +68,14 @@ bool ATLASCuts<SpacePoint>::singleSeedCut(
 }
 
 template <typename SpacePoint>
-std::vector<
-    typename CandidatesForMiddleSp<InternalSpacePoint<SpacePoint>>::value_type>
+std::vector<typename CandidatesForMiddleSp<
+    const InternalSpacePoint<SpacePoint>>::value_type>
 ATLASCuts<SpacePoint>::cutPerMiddleSP(
     std::vector<typename CandidatesForMiddleSp<
-        InternalSpacePoint<SpacePoint>>::value_type>
+        const InternalSpacePoint<SpacePoint>>::value_type>
         seedCandidates) const {
   std::vector<typename CandidatesForMiddleSp<
-      InternalSpacePoint<SpacePoint>>::value_type>
+      const InternalSpacePoint<SpacePoint>>::value_type>
       newSeedsVector;
 
   if (seedCandidates.size() <= 1) {
diff --git a/Tests/UnitTests/Plugins/Sycl/Seeding/SeedFinderSyclTest.cpp b/Tests/UnitTests/Plugins/Sycl/Seeding/SeedFinderSyclTest.cpp
index 6221f458156..8700384f30c 100644
--- a/Tests/UnitTests/Plugins/Sycl/Seeding/SeedFinderSyclTest.cpp
+++ b/Tests/UnitTests/Plugins/Sycl/Seeding/SeedFinderSyclTest.cpp
@@ -1,11 +1,12 @@
 // This file is part of the Acts project.
 //
-// Copyright (C) 2020-2023 CERN for the benefit of the Acts project
+// Copyright (C) 2023 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 http://mozilla.org/MPL/2.0/.
 
+#include "Acts/EventData/SpacePointData.hpp"
 #include "Acts/Plugins/Sycl/Seeding/SeedFinder.hpp"
 #include "Acts/Plugins/Sycl/Utilities/QueueWrapper.hpp"
 #include "Acts/Seeding/BinFinder.hpp"
@@ -247,9 +248,12 @@ auto main(int argc, char** argv) -> int {
   group_count = 0;
   std::vector<std::vector<Acts::Seed<SpacePoint>>> seedVector_sycl;
 
+  Acts::SpacePointData spacePointData;
+  spacePointData.resize(spVec.size());
+
   for (auto [bottom, middle, top] : spGroup) {
     seedVector_sycl.push_back(syclSeedFinder.createSeedsForGroup(
-        spGroup.grid(), bottom, middle, top));
+        spacePointData, spGroup.grid(), bottom, middle, top));
     group_count++;
     if (!cmdlTool.allgroup && group_count >= cmdlTool.groups) {
       break;

From 22c40d931528d14bbd3c7e3d5c2b6bf9fe680a90 Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Fri, 17 Mar 2023 10:10:37 +0100
Subject: [PATCH 09/14] docs

---
 Core/include/Acts/Seeding/SeedFilter.hpp           | 3 +++
 Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp | 1 +
 Core/include/Acts/Seeding/SeedFinderUtils.hpp      | 1 +
 3 files changed, 5 insertions(+)

diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index 0b4a7d209e7..f937aafb110 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -52,6 +52,7 @@ class SeedFilter {
 
   /// Create InternalSeeds for the all seeds with the same bottom and middle
   /// space point and discard all others.
+  /// @param spacePointData Auxiliary variables used by the seeding 
   /// @param bottomSP fixed bottom space point
   /// @param middleSP fixed middle space point
   /// @param topSpVec vector containing all space points that may be compatible
@@ -73,6 +74,7 @@ class SeedFilter {
           candidates_collector) const;
 
   /// Filter seeds once all seeds for one middle space point have been created
+  /// @param spacePointData Auxiliary variables used by the seeding 
   /// @param candidates_collector collection of seed candidates
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
@@ -86,6 +88,7 @@ class SeedFilter {
       const;
 
   /// Filter seeds once all seeds for one middle space point have been created
+  /// @param spacePointData Auxiliary variables used by the seeding 
   /// @param candidates collection of seed candidates
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
diff --git a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
index 70396a9b754..70f895366ec 100644
--- a/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderOrthogonal.hpp
@@ -212,6 +212,7 @@ class SeedFinderOrthogonal {
    * @param seedFilterState  holds quantities used in seed filter
    * @param candidates_collector The container to write the resulting
    * seed candidates to.
+   * @param spacePointData Auxiliary variables used by the seeding
    */
   void filterCandidates(
       const SeedFinderOptions &options, internal_sp_t &middle,
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.hpp b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
index 1e9e45baa92..2b2bb344453 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
@@ -52,6 +52,7 @@ LinCircle transformCoordinates(const external_spacepoint_t& sp,
 ///
 /// @tparam external_spacepoint_t The external spacepoint type.
 ///
+/// @param[in] spacePointData Auxiliary variables used by the seeding 
 /// @param[in] vec The list of bottom or top spacepoints
 /// @param[in] spM The middle spacepoint.
 /// @param[in] bottom Should be true if vec are bottom spacepoints.

From e3ec89c85b7db793cad6c5ad1e480893ae3a23ee Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Fri, 17 Mar 2023 10:14:50 +0100
Subject: [PATCH 10/14] once again format ...

---
 Core/include/Acts/Seeding/SeedFilter.hpp      | 6 +++---
 Core/include/Acts/Seeding/SeedFinderUtils.hpp | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Core/include/Acts/Seeding/SeedFilter.hpp b/Core/include/Acts/Seeding/SeedFilter.hpp
index f937aafb110..e92d717f292 100644
--- a/Core/include/Acts/Seeding/SeedFilter.hpp
+++ b/Core/include/Acts/Seeding/SeedFilter.hpp
@@ -52,7 +52,7 @@ class SeedFilter {
 
   /// Create InternalSeeds for the all seeds with the same bottom and middle
   /// space point and discard all others.
-  /// @param spacePointData Auxiliary variables used by the seeding 
+  /// @param spacePointData Auxiliary variables used by the seeding
   /// @param bottomSP fixed bottom space point
   /// @param middleSP fixed middle space point
   /// @param topSpVec vector containing all space points that may be compatible
@@ -74,7 +74,7 @@ class SeedFilter {
           candidates_collector) const;
 
   /// Filter seeds once all seeds for one middle space point have been created
-  /// @param spacePointData Auxiliary variables used by the seeding 
+  /// @param spacePointData Auxiliary variables used by the seeding
   /// @param candidates_collector collection of seed candidates
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
@@ -88,7 +88,7 @@ class SeedFilter {
       const;
 
   /// Filter seeds once all seeds for one middle space point have been created
-  /// @param spacePointData Auxiliary variables used by the seeding 
+  /// @param spacePointData Auxiliary variables used by the seeding
   /// @param candidates collection of seed candidates
   /// @param numQualitySeeds number of high quality seeds in seed confirmation
   /// @param outIt Output iterator for the seeds
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.hpp b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
index 2b2bb344453..96cc1be2b31 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
@@ -52,7 +52,7 @@ LinCircle transformCoordinates(const external_spacepoint_t& sp,
 ///
 /// @tparam external_spacepoint_t The external spacepoint type.
 ///
-/// @param[in] spacePointData Auxiliary variables used by the seeding 
+/// @param[in] spacePointData Auxiliary variables used by the seeding
 /// @param[in] vec The list of bottom or top spacepoints
 /// @param[in] spM The middle spacepoint.
 /// @param[in] bottom Should be true if vec are bottom spacepoints.

From 0a7aa3f8154e3188df859a4842f8e9410d14ac21 Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Fri, 17 Mar 2023 10:30:42 +0100
Subject: [PATCH 11/14] docs

---
 docs/core/seeding.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/core/seeding.md b/docs/core/seeding.md
index fb7f4edd3bc..3c3424a7dd6 100644
--- a/docs/core/seeding.md
+++ b/docs/core/seeding.md
@@ -219,7 +219,7 @@ The seed confirmation also sets a limit on the number of seeds produced for each
 which retains only the higher quality seeds. If this limit is exceeded, the algorithm
 checks if there is any low-quality seed in the seed container of this middle SP that can be removed.
 
-:::{doxygenfunction} Acts::SeedFilter::filterSeeds_1SpFixed (CandidatesForMiddleSp<InternalSpacePoint<external_spacepoint_t>>&,std::size_t&,std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>>) const
+:::{doxygenfunction} Acts::SeedFilter::filterSeeds_1SpFixed (Acts::SpacePointData &spacePointData, CandidatesForMiddleSp<const InternalSpacePoint<external_spacepoint_t>>&,std::size_t&,std::back_insert_iterator<std::vector<Seed<external_spacepoint_t>>>) const
 :outline:
 :::
 

From 1c075753f05bdc282dfec79328fb03d6f6b0c4f2 Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Fri, 17 Mar 2023 11:09:11 +0100
Subject: [PATCH 12/14] minor bugfix

---
 Core/include/Acts/Seeding/SeedFinder.ipp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index 257f521993a..bc3eb4aeeed 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -1,3 +1,4 @@
+// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2023 CERN for the benefit of the Acts project
@@ -309,8 +310,8 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
 
   std::size_t numTopSP = state.compatTopSP.size();
 
-  transformCoordinates(state.compatBottomSP, spM, true, state.linCircleBottom);
-  transformCoordinates(state.compatTopSP, spM, false, state.linCircleTop);
+  transformCoordinates(state.spacePointData, state.compatBottomSP, spM, true, state.linCircleBottom);
+  transformCoordinates(state.spacePointData, state.compatTopSP, spM, false, state.linCircleTop);
 
   // sort: make index vector
   std::vector<std::size_t> sorted_bottoms(state.linCircleBottom.size());

From a99004328a708eaf79d3f60647b6c11ddac2a20d Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Fri, 17 Mar 2023 11:34:57 +0100
Subject: [PATCH 13/14] reference holder

---
 Core/include/Acts/Seeding/InternalSpacePoint.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Core/include/Acts/Seeding/InternalSpacePoint.hpp b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
index 10aa06d4c0f..f3c467514cc 100644
--- a/Core/include/Acts/Seeding/InternalSpacePoint.hpp
+++ b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
@@ -12,6 +12,7 @@
 
 #include <array>
 #include <cmath>
+#include <functional>
 #include <limits>
 
 namespace Acts {
@@ -52,7 +53,7 @@ class InternalSpacePoint {
   float m_r;               // radius       in beam system coordinates
   float m_varianceR;       //
   float m_varianceZ;       //
-  const SpacePoint& m_sp;  // external space point
+  std::reference_wrapper<const SpacePoint> m_sp;  // external space point
 };
 
 /////////////////////////////////////////////////////////////////////////////////

From 6e596b0fea165fc5c4578bde05fa9aa7ead13279 Mon Sep 17 00:00:00 2001
From: Carlo Varni <carlovarni@pccvarni.dyndns.cern.ch>
Date: Fri, 17 Mar 2023 11:44:14 +0100
Subject: [PATCH 14/14] format

---
 Core/include/Acts/Seeding/InternalSpacePoint.hpp | 12 ++++++------
 Core/include/Acts/Seeding/SeedFinder.ipp         |  7 ++++---
 Core/include/Acts/Seeding/SeedFinderUtils.hpp    | 10 +++++-----
 Core/include/Acts/Seeding/SeedFinderUtils.ipp    | 14 +++++++-------
 4 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/Core/include/Acts/Seeding/InternalSpacePoint.hpp b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
index f3c467514cc..8d202337d20 100644
--- a/Core/include/Acts/Seeding/InternalSpacePoint.hpp
+++ b/Core/include/Acts/Seeding/InternalSpacePoint.hpp
@@ -47,12 +47,12 @@ class InternalSpacePoint {
 
  protected:
   std::size_t m_index;
-  float m_x;               // x-coordinate in beam system coordinates
-  float m_y;               // y-coordinate in beam system coordinates
-  float m_z;               // z-coordinate in beam system coordinetes
-  float m_r;               // radius       in beam system coordinates
-  float m_varianceR;       //
-  float m_varianceZ;       //
+  float m_x;          // x-coordinate in beam system coordinates
+  float m_y;          // y-coordinate in beam system coordinates
+  float m_z;          // z-coordinate in beam system coordinetes
+  float m_r;          // radius       in beam system coordinates
+  float m_varianceR;  //
+  float m_varianceZ;  //
   std::reference_wrapper<const SpacePoint> m_sp;  // external space point
 };
 
diff --git a/Core/include/Acts/Seeding/SeedFinder.ipp b/Core/include/Acts/Seeding/SeedFinder.ipp
index bc3eb4aeeed..5cc1a72fe0c 100644
--- a/Core/include/Acts/Seeding/SeedFinder.ipp
+++ b/Core/include/Acts/Seeding/SeedFinder.ipp
@@ -1,4 +1,3 @@
-// -*- C++ -*-
 // This file is part of the Acts project.
 //
 // Copyright (C) 2023 CERN for the benefit of the Acts project
@@ -310,8 +309,10 @@ inline void SeedFinder<external_spacepoint_t, platform_t>::filterCandidates(
 
   std::size_t numTopSP = state.compatTopSP.size();
 
-  transformCoordinates(state.spacePointData, state.compatBottomSP, spM, true, state.linCircleBottom);
-  transformCoordinates(state.spacePointData, state.compatTopSP, spM, false, state.linCircleTop);
+  transformCoordinates(state.spacePointData, state.compatBottomSP, spM, true,
+                       state.linCircleBottom);
+  transformCoordinates(state.spacePointData, state.compatTopSP, spM, false,
+                       state.linCircleTop);
 
   // sort: make index vector
   std::vector<std::size_t> sorted_bottoms(state.linCircleBottom.size());
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.hpp b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
index 9761ddb812b..fa695b1c033 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.hpp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.hpp
@@ -66,11 +66,11 @@ void transformCoordinates(
     std::vector<LinCircle>& linCircleVec);
 
 template <typename external_spacepoint_t, typename callable_t>
-void transformCoordinates(
-    Acts::SpacePointData& spacePointData,
-    const std::vector<external_spacepoint_t*>& vec,
-    const external_spacepoint_t& spM, bool bottom,
-    std::vector<LinCircle>& linCircleVec, callable_t&& extractFunction);
+void transformCoordinates(Acts::SpacePointData& spacePointData,
+                          const std::vector<external_spacepoint_t*>& vec,
+                          const external_spacepoint_t& spM, bool bottom,
+                          std::vector<LinCircle>& linCircleVec,
+                          callable_t&& extractFunction);
 
 /// @brief Check the compatibility of spacepoint coordinates in xyz assuming the Bottom-Middle direction with the strip meassument details
 ///
diff --git a/Core/include/Acts/Seeding/SeedFinderUtils.ipp b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
index 9eaeef2422a..f273c145482 100644
--- a/Core/include/Acts/Seeding/SeedFinderUtils.ipp
+++ b/Core/include/Acts/Seeding/SeedFinderUtils.ipp
@@ -74,15 +74,16 @@ inline void transformCoordinates(
   };
 
   transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(
-      spacePointData, vec, spM, bottom, linCircleVec, std::move(extractFunction));
+      spacePointData, vec, spM, bottom, linCircleVec,
+      std::move(extractFunction));
 }
 
 template <typename external_spacepoint_t, typename callable_t>
-inline void transformCoordinates(
-    Acts::SpacePointData& spacePointData,
-    const std::vector<external_spacepoint_t*>& vec,
-    const external_spacepoint_t& spM, bool bottom,
-    std::vector<LinCircle>& linCircleVec, callable_t&& extractFunction) {
+inline void transformCoordinates(Acts::SpacePointData& spacePointData,
+                                 const std::vector<external_spacepoint_t*>& vec,
+                                 const external_spacepoint_t& spM, bool bottom,
+                                 std::vector<LinCircle>& linCircleVec,
+                                 callable_t&& extractFunction) {
   std::vector<std::size_t> indexes(vec.size());
   for (unsigned int i(0); i < indexes.size(); i++) {
     indexes[i] = i;
@@ -140,7 +141,6 @@ inline void transformCoordinates(
     l.z = sp->z();
     l.r = sp->radius();
 
-
     linCircleVec[idx] = l;
     spacePointData.setDeltaR(sp->index(),
                              std::sqrt((x * x) + (y * y) + (deltaZ * deltaZ)));