chore: Use camel case spacePoint (#5106)

Consistently use
- `SpacePoint` for classes and file names
- `spacePoint` for variables
- `space point` in comments and text

Author: andiwand

Core/include/Acts/EventData/CompositeSpacePoint.hpp

@@ -60,7 +60,7 @@ concept CompositeSpacePoint = requires(const SpacePointType sp) {
   { sp.measuresLoc1() } -> std::same_as<bool>;
 };
 
-/// @brief Define the Space Point pointer concept as an ordinary / smart pointer
+/// @brief Define the space point pointer concept as an ordinary / smart pointer
 ///        over space points
 template <typename SpacePoint_t>
 concept CompositeSpacePointPtr =

Core/include/Acts/EventData/Seed.hpp

@@ -14,21 +14,21 @@
 namespace Acts {
 
 /// Seed built from N external space points.
-template <typename external_spacepoint_t, std::size_t N = 3ul>
+template <typename external_space_point_t, std::size_t N = 3ul>
 class Seed {
   static_assert(N >= 3ul);
 
  public:
   /// Type of the external space point
-  using value_type = external_spacepoint_t;
+  using value_type = external_space_point_t;
   /// Number of space points in the seed
   static constexpr std::size_t DIM = N;
 
   /// Constructor from N space points
   /// @param points The space points to build the seed from
   template <typename... args_t>
     requires(sizeof...(args_t) == N) &&
-            (std::same_as<external_spacepoint_t, args_t> && ...)
+            (std::same_as<external_space_point_t, args_t> && ...)
   explicit Seed(const args_t&... points);
 
   /// Set the z-coordinate of the vertex
@@ -40,7 +40,7 @@ class Seed {
 
   /// Get the space points in the seed
   /// @return Array of pointers to the space points
-  const std::array<const external_spacepoint_t*, N>& sp() const;
+  const std::array<const external_space_point_t*, N>& sp() const;
   /// Get the z-coordinate of the vertex
   /// @return The vertex z-coordinate
   float z() const;
@@ -49,7 +49,7 @@ class Seed {
   float seedQuality() const;
 
  private:
-  std::array<const external_spacepoint_t*, N> m_spacepoints{};
+  std::array<const external_space_point_t*, N> m_spacepoints{};
   float m_vertexZ{0.f};
   float m_seedQuality{-std::numeric_limits<float>::infinity()};
 };

Core/include/Acts/EventData/Seed.ipp

@@ -12,36 +12,36 @@
 
 namespace Acts {
 
-template <typename external_spacepoint_t, std::size_t N>
+template <typename external_space_point_t, std::size_t N>
 template <typename... args_t>
   requires(sizeof...(args_t) == N) &&
-          (std::same_as<external_spacepoint_t, args_t> && ...)
-Seed<external_spacepoint_t, N>::Seed(const args_t&... points)
+          (std::same_as<external_space_point_t, args_t> && ...)
+Seed<external_space_point_t, N>::Seed(const args_t&... points)
     : m_spacepoints({&points...}) {}
 
-template <typename external_spacepoint_t, std::size_t N>
-void Seed<external_spacepoint_t, N>::setVertexZ(float vertex) {
+template <typename external_space_point_t, std::size_t N>
+void Seed<external_space_point_t, N>::setVertexZ(float vertex) {
   m_vertexZ = vertex;
 }
 
-template <typename external_spacepoint_t, std::size_t N>
-void Seed<external_spacepoint_t, N>::setQuality(float seedQuality) {
+template <typename external_space_point_t, std::size_t N>
+void Seed<external_space_point_t, N>::setQuality(float seedQuality) {
   m_seedQuality = seedQuality;
 }
 
-template <typename external_spacepoint_t, std::size_t N>
-const std::array<const external_spacepoint_t*, N>&
-Seed<external_spacepoint_t, N>::sp() const {
+template <typename external_space_point_t, std::size_t N>
+const std::array<const external_space_point_t*, N>&
+Seed<external_space_point_t, N>::sp() const {
   return m_spacepoints;
 }
 
-template <typename external_spacepoint_t, std::size_t N>
-float Seed<external_spacepoint_t, N>::z() const {
+template <typename external_space_point_t, std::size_t N>
+float Seed<external_space_point_t, N>::z() const {
   return m_vertexZ;
 }
 
-template <typename external_spacepoint_t, std::size_t N>
-float Seed<external_spacepoint_t, N>::seedQuality() const {
+template <typename external_space_point_t, std::size_t N>
+float Seed<external_space_point_t, N>::seedQuality() const {
   return m_seedQuality;
 }
 

Core/include/Acts/EventData/SpacePointContainer.hpp

@@ -47,7 +47,7 @@ class SpacePointContainer {
       Acts::SpacePointContainer<container_t, holder_t>>;
 
  public:
-  /// Space point proxy type
+  /// space point proxy type
   using SpacePointProxyType =
       Acts::SpacePointProxy<Acts::SpacePointContainer<container_t, holder_t>>;
 
@@ -106,10 +106,10 @@ class SpacePointContainer {
 
   // move operations
   /// Move constructor
-  /// @param other Space point container to move from
+  /// @param other space point container to move from
   SpacePointContainer(SpacePointContainer&& other) noexcept = default;
   /// Move assignment operator
-  /// @param other Space point container to move from
+  /// @param other space point container to move from
   /// @return Reference to this container
   SpacePointContainer& operator=(SpacePointContainer&& other) noexcept =
       default;

Core/include/Acts/EventData/SpacePointContainer2.hpp

@@ -725,8 +725,8 @@ class SpacePointContainer2 {
     assert(index < m_varianceZColumn->size() && "Index out of bounds");
     return m_varianceZColumn->proxy(*this)[index];
   }
-  /// Const access to the variance in R direction of the space
-  /// point at the given index.
+  /// Const access to the variance in R direction of the space point at the
+  /// given index.
   /// @param index The index of the space point.
   /// @return A const reference to the variance in R direction of the space point.
   float varianceR(Index index) const noexcept {

Core/include/Acts/Seeding/CandidatesForMiddleSp.hpp

@@ -13,7 +13,7 @@
 namespace Acts {
 
 /// @brief A description of a triplet candidate.
-/// @tparam external_space_point_t  The external spacepoint type.
+/// @tparam external_space_point_t  The external space point type.
 template <typename external_space_point_t>
 struct TripletCandidate {
   /// @brief Default Constructor
@@ -46,10 +46,10 @@ struct TripletCandidate {
 
 /// @class CandidatesForMiddleSp
 /// The CandidatesForMiddleSp collects the triplet candidates given a
-/// fixed middle spacepoint. It internally stores the triplet candidates
+/// fixed middle space point. It internally stores the triplet candidates
 /// keeping only those with the higher quality.
 ///
-/// @tparam external_space_point_t The external spacepoint type.
+/// @tparam external_space_point_t The external space point type.
 
 template <typename external_space_point_t>
 concept SatisfyCandidateConcept = requires(external_space_point_t spacePoint) {

Core/include/Acts/Seeding/SeedFilter.hpp

@@ -32,22 +32,22 @@ struct SeedFilterState {
 
 /// Filter seeds at various stages with the currently
 /// available information.
-template <typename external_spacepoint_t>
+template <typename external_space_point_t>
 class SeedFilter final {
  public:
   /// Constructor with configuration and optional experimental cuts
   /// @param config Seed filter configuration
   /// @param expCuts Optional experimental cuts (defaults to nullptr)
   explicit SeedFilter(
       const SeedFilterConfig& config,
-      IExperimentCuts<external_spacepoint_t>* expCuts = nullptr);
+      IExperimentCuts<external_space_point_t>* expCuts = nullptr);
   /// Constructor with configuration, logger, and optional experimental cuts
   /// @param config Seed filter configuration
   /// @param logger Logger for output messages
   /// @param expCuts Optional experimental cuts (defaults to nullptr)
   explicit SeedFilter(
       const SeedFilterConfig& config, std::unique_ptr<const Logger> logger,
-      IExperimentCuts<external_spacepoint_t>* expCuts = nullptr);
+      IExperimentCuts<external_space_point_t>* expCuts = nullptr);
 
   /// Create Seeds for the all seeds with the same bottom and middle
   /// space point and discard all others.
@@ -62,13 +62,13 @@ class SeedFilter final {
   /// @param candidatesCollector container for the seed candidates
   void filterSeeds_2SpFixed(
       const SpacePointMutableData& mutableData,
-      const external_spacepoint_t& bottomSp,
-      const external_spacepoint_t& middleSp,
-      const std::vector<const external_spacepoint_t*>& topSpVec,
+      const external_space_point_t& bottomSp,
+      const external_space_point_t& middleSp,
+      const std::vector<const external_space_point_t*>& topSpVec,
       const std::vector<float>& invHelixDiameterVec,
       const std::vector<float>& impactParametersVec,
       SeedFilterState& seedFilterState,
-      CandidatesForMiddleSp<const external_spacepoint_t>& candidatesCollector)
+      CandidatesForMiddleSp<const external_space_point_t>& candidatesCollector)
       const;
 
   /// Filter seeds once all seeds for one middle space point have been created
@@ -79,7 +79,7 @@ class SeedFilter final {
   template <typename collection_t>
   void filterSeeds_1SpFixed(
       SpacePointMutableData& mutableData,
-      CandidatesForMiddleSp<const external_spacepoint_t>& candidatesCollector,
+      CandidatesForMiddleSp<const external_space_point_t>& candidatesCollector,
       collection_t& outputCollection) const;
 
   /// Filter seeds once all seeds for one middle space point have been created
@@ -92,15 +92,15 @@ class SeedFilter final {
   void filterSeeds_1SpFixed(
       SpacePointMutableData& mutableData,
       std::vector<typename CandidatesForMiddleSp<
-          const external_spacepoint_t>::value_type>& candidates,
+          const external_space_point_t>::value_type>& candidates,
       const std::size_t numQualitySeeds, collection_t& outputCollection) const;
 
   /// Get the seed filter configuration
   /// @return Copy of the seed filter configuration
   const SeedFilterConfig getSeedFilterConfig() const { return m_cfg; }
   /// Get the experimental cuts pointer
   /// @return Pointer to experimental cuts (may be nullptr)
-  const IExperimentCuts<external_spacepoint_t>* getExperimentCuts() const {
+  const IExperimentCuts<external_space_point_t>* getExperimentCuts() const {
     return m_experimentCuts;
   }
 
@@ -110,7 +110,7 @@ class SeedFilter final {
   const SeedFilterConfig m_cfg;
   std::unique_ptr<const Logger> m_logger =
       getDefaultLogger("Filter", Logging::Level::INFO);
-  const IExperimentCuts<external_spacepoint_t>* m_experimentCuts;
+  const IExperimentCuts<external_space_point_t>* m_experimentCuts;
 };
 
 }  // namespace Acts

Core/include/Acts/Seeding/SeedFilter.ipp

@@ -18,28 +18,28 @@
 
 namespace Acts {
 
-template <typename external_spacepoint_t>
-SeedFilter<external_spacepoint_t>::SeedFilter(
+template <typename external_space_point_t>
+SeedFilter<external_space_point_t>::SeedFilter(
     const SeedFilterConfig& config,
-    IExperimentCuts<external_spacepoint_t>* expCuts /* = 0*/)
+    IExperimentCuts<external_space_point_t>* expCuts /* = 0*/)
     : m_cfg(config), m_experimentCuts(expCuts) {}
 
-template <typename external_spacepoint_t>
-SeedFilter<external_spacepoint_t>::SeedFilter(
+template <typename external_space_point_t>
+SeedFilter<external_space_point_t>::SeedFilter(
     const SeedFilterConfig& config, std::unique_ptr<const Logger> logger,
-    IExperimentCuts<external_spacepoint_t>* expCuts /* = 0*/)
+    IExperimentCuts<external_space_point_t>* expCuts /* = 0*/)
     : m_cfg(config), m_logger(std::move(logger)), m_experimentCuts(expCuts) {}
 
-template <typename external_spacepoint_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
+template <typename external_space_point_t>
+void SeedFilter<external_space_point_t>::filterSeeds_2SpFixed(
     const SpacePointMutableData& mutableData,
-    const external_spacepoint_t& bottomSp,
-    const external_spacepoint_t& middleSp,
-    const std::vector<const external_spacepoint_t*>& topSpVec,
+    const external_space_point_t& bottomSp,
+    const external_space_point_t& middleSp,
+    const std::vector<const external_space_point_t*>& topSpVec,
     const std::vector<float>& invHelixDiameterVec,
     const std::vector<float>& impactParametersVec,
     SeedFilterState& seedFilterState,
-    CandidatesForMiddleSp<const external_spacepoint_t>& candidatesCollector)
+    CandidatesForMiddleSp<const external_space_point_t>& candidatesCollector)
     const {
   // seed confirmation
   SeedConfirmationRangeConfig seedConfRange;
@@ -234,11 +234,11 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_2SpFixed(
 
 // after creating all seeds with a common middle space point, filter again
 
-template <typename external_spacepoint_t>
+template <typename external_space_point_t>
 template <typename collection_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
+void SeedFilter<external_space_point_t>::filterSeeds_1SpFixed(
     SpacePointMutableData& mutableData,
-    CandidatesForMiddleSp<const external_spacepoint_t>& candidatesCollector,
+    CandidatesForMiddleSp<const external_space_point_t>& candidatesCollector,
     collection_t& outputCollection) const {
   // retrieve all candidates
   // this collection is already sorted
@@ -249,12 +249,12 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
                        outputCollection);
 }
 
-template <typename external_spacepoint_t>
+template <typename external_space_point_t>
 template <typename collection_t>
-void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
+void SeedFilter<external_space_point_t>::filterSeeds_1SpFixed(
     SpacePointMutableData& mutableData,
     std::vector<typename CandidatesForMiddleSp<
-        const external_spacepoint_t>::value_type>& candidates,
+        const external_space_point_t>::value_type>& candidates,
     const std::size_t numQualitySeeds, collection_t& outputCollection) const {
   if (m_experimentCuts != nullptr) {
     candidates = m_experimentCuts->cutPerMiddleSP(std::move(candidates));
@@ -294,7 +294,7 @@ void SeedFilter<external_spacepoint_t>::filterSeeds_1SpFixed(
     mutableData.setQuality(medium->index(), bestSeedQuality);
     mutableData.setQuality(top->index(), bestSeedQuality);
 
-    Seed<external_spacepoint_t> seed{*bottom, *medium, *top};
+    Seed<external_space_point_t> seed{*bottom, *medium, *top};
     seed.setVertexZ(zOrigin);
     seed.setQuality(bestSeedQuality);