chore: More camel case spacePoint

Core/include/Acts/EventData/Seed.hpp

@@ -49,7 +49,7 @@ class Seed {
   float seedQuality() const;
 
  private:
-  std::array<const external_space_point_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

@@ -17,7 +17,7 @@ template <typename... args_t>
   requires(sizeof...(args_t) == N) &&
           (std::same_as<external_space_point_t, args_t> && ...)
 Seed<external_space_point_t, N>::Seed(const args_t&... points)
-    : m_spacepoints({&points...}) {}
+    : m_spacePoints({&points...}) {}
 
 template <typename external_space_point_t, std::size_t N>
 void Seed<external_space_point_t, N>::setVertexZ(float vertex) {
@@ -32,7 +32,7 @@ void Seed<external_space_point_t, N>::setQuality(float seedQuality) {
 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;
+  return m_spacePoints;
 }
 
 template <typename external_space_point_t, std::size_t N>

Core/include/Acts/EventData/SpacePointContainer2.hpp

@@ -106,11 +106,11 @@ class SpacePointContainer2 {
   /// @return A mutable proxy to the newly created space point.
   MutableProxy createSpacePoint() noexcept;
 
-  /// Copies the specified columns from another spacepoint to this spacepoint
-  /// @param index The index of the spacepoint to copy to in this container.
+  /// Copies the specified columns from another space point to this space point
+  /// @param index The index of the space point to copy to in this container.
   /// @param otherContainer The space point container to copy from.
-  /// @param otherIndex The index of the spacepoint to copy from in the other container.
-  /// @param columnsToCopy The columns to copy from the other spacepoint.
+  /// @param otherIndex The index of the space point to copy from in the other container.
+  /// @param columnsToCopy The columns to copy from the other space point.
   void copyFrom(Index index, const SpacePointContainer2 &otherContainer,
                 Index otherIndex, SpacePointColumns columnsToCopy);
 

Core/include/Acts/Seeding/EstimateTrackParamsFromSeed.hpp

@@ -68,14 +68,14 @@ FreeVector estimateTrackParamsFromSeed(const Vector3& sp0, double t0,
 
 /// Estimate free track parameters from three space points
 ///
-/// @tparam spacepoint_iterator_t The type of space point iterator
+/// @tparam space_point_range_t The type of space point range
 ///
 /// @param spRange is the range of space points
 /// @param bField is the magnetic field vector
 ///
 /// @return the free parameters
-template <std::ranges::range spacepoint_range_t>
-FreeVector estimateTrackParamsFromSeed(spacepoint_range_t spRange,
+template <std::ranges::range space_point_range_t>
+FreeVector estimateTrackParamsFromSeed(space_point_range_t spRange,
                                        const Vector3& bField) {
   // Check the number of provided space points
   if (spRange.size() != 3) {
@@ -121,7 +121,7 @@ Result<BoundVector> estimateTrackParamsFromSeed(
 
 /// Estimate bound track parameters from three space points
 ///
-/// @tparam spacepoint_iterator_t The type of space point iterator
+/// @tparam space_point_range_t The type of space point range
 ///
 /// @param gctx is the geometry context
 /// @param spRange is the range of space points
@@ -130,9 +130,9 @@ Result<BoundVector> estimateTrackParamsFromSeed(
 /// @param bField is the magnetic field vector
 ///
 /// @return bound parameters
-template <std::ranges::range spacepoint_range_t>
+template <std::ranges::range space_point_range_t>
 Result<BoundVector> estimateTrackParamsFromSeed(const GeometryContext& gctx,
-                                                spacepoint_range_t spRange,
+                                                space_point_range_t spRange,
                                                 const Surface& surface,
                                                 const Vector3& bField) {
   const FreeVector freeParams = estimateTrackParamsFromSeed(spRange, bField);

Core/include/Acts/Seeding/SeedFinderGbts.hpp

@@ -74,7 +74,7 @@ class SeedFinderGbts {
                      Acts::getDefaultLogger("Finder",
                                             Acts::Logging::Level::INFO));
 
-  /// Create seeds from spacepoints in a region of interest.
+  /// Create seeds from space points in a region of interest.
   /// @param roi Region of interest descriptor
   /// @param spacePoints Space point container
   /// @param maxLayers Maximum number of layers

Core/include/Acts/Seeding/SeedFinderOrthogonal.ipp

@@ -518,7 +518,7 @@ void SeedFinderOrthogonal<external_space_point_t>::processFromMiddleSP(
   range_t top_r = validTupleOrthoRangeLH(middle);
 
   /*
-   * Calculate the value of cot(θ) for this middle spacepoint.
+   * Calculate the value of cot(θ) for this middle space point.
    */
   float myCotTheta =
       std::max(std::abs(middle.z() / middle.radius()), m_config.cotThetaMax);
@@ -722,7 +722,7 @@ void SeedFinderOrthogonal<external_space_point_t>::createSeeds(
                 "Output iterator container type must accept seeds.");
   static_assert(std::is_same_v<typename input_container_t::value_type,
                                external_space_point_t>,
-                "Input container must contain external spacepoints.");
+                "Input container must contain external space points.");
 
   /*
    * Sadly, for the time being, we will need to construct our internal space

Core/include/Acts/Seeding/detail/CylindricalSpacePointGrid.hpp

@@ -126,12 +126,12 @@ class CylindricalSpacePointGridCreator {
       const Logger& logger = getDummyLogger());
 
   template <typename external_space_point_t,
-            typename external_spacepoint_iterator_t>
+            typename external_space_point_iterator_t>
   static void fillGrid(const SeedFinderConfig<external_space_point_t>& config,
                        const SeedFinderOptions& options,
                        CylindricalSpacePointGrid<external_space_point_t>& grid,
-                       external_spacepoint_iterator_t spBegin,
-                       external_spacepoint_iterator_t spEnd,
+                       external_space_point_iterator_t spBegin,
+                       external_space_point_iterator_t spEnd,
                        const Logger& logger = getDummyLogger());
 
   template <typename external_space_point_t, typename external_collection_t>

Core/include/Acts/Seeding/detail/CylindricalSpacePointGrid.ipp

@@ -148,13 +148,13 @@ CylindricalSpacePointGridCreator::createGrid(
 }
 
 template <typename external_space_point_t,
-          typename external_spacepoint_iterator_t>
+          typename external_space_point_iterator_t>
 void CylindricalSpacePointGridCreator::fillGrid(
     const SeedFinderConfig<external_space_point_t>& config,
     const SeedFinderOptions& options,
     CylindricalSpacePointGrid<external_space_point_t>& grid,
-    external_spacepoint_iterator_t spBegin,
-    external_spacepoint_iterator_t spEnd, const Logger& logger) {
+    external_space_point_iterator_t spBegin,
+    external_space_point_iterator_t spEnd, const Logger& logger) {
   static_cast<void>(options);
 
   if (config.seedFilter == nullptr) {
@@ -179,7 +179,7 @@ void CylindricalSpacePointGridCreator::fillGrid(
   ACTS_VERBOSE("Fetching " << std::distance(spBegin, spEnd)
                            << " space points to the grid");
   std::size_t counter = 0ul;
-  for (external_spacepoint_iterator_t it = spBegin; it != spEnd; ++it) {
+  for (external_space_point_iterator_t it = spBegin; it != spEnd; ++it) {
     const external_space_point_t& sp = *it;
 
     // remove SPs according to experiment specific cuts

Core/include/Acts/Vertexing/HoughVertexFinder2.hpp

@@ -19,12 +19,12 @@
 
 namespace Acts {
 
-/// @brief Implements the vertex finder based on the spacepoints using Hough transform
+/// @brief Implements the vertex finder based on the space points using Hough transform
 /// For more information, see arXiv:2410.14494
 /// 0. Assumes there is only 1 vertex and that it has a high multiplicity
 /// 1. Estimates what eta range is really necessary
-/// 2. Creates Hough space (z_vtx - cot(theta)) from spacepoints within that eta
-/// range
+/// 2. Creates Hough space (z_vtx - cot(theta)) from space points within that
+/// eta range
 /// 3. Subtracts the coincidentally crossed lines in the Hough space
 /// 4. Makes a projection to the Z axis and finds a peak - that is the vertex
 /// position
@@ -34,7 +34,7 @@ class HoughVertexFinder2 {
  public:
   /// Configuration struct
   struct Config {
-    /// Ideal amount of spacepoints; |eta| range will be limited to
+    /// Ideal amount of space points; |eta| range will be limited to
     /// contain approximately this amount of SPs
     std::uint32_t targetSPs = 10000;
 

Examples/Algorithms/Utilities/src/ProtoTracksToParameters.cpp

@@ -87,10 +87,10 @@ ProcessCode ProtoTracksToParameters::execute(
     ACTS_VERBOSE("Try to get seed from proto track with " << track.size()
                                                           << " hits");
     // Make proto track unique with respect to volume and layer so we don't get
-    // a seed where we have two spacepoints on the same layer
+    // a seed where we have two space points on the same layer
 
     // Here, we want to create a seed only if the proto track with removed
-    // unique layer-volume spacepoints has 3 or more hits. However, if this is
+    // unique layer-volume space points has 3 or more hits. However, if this is
     // the case, we want to keep the whole proto track. Therefore, we operate on
     // a tmpTrack.
     std::ranges::sort(track, {}, [&](const auto &t) {

Python/Examples/tests/root_file_hashes.txt

@@ -87,4 +87,4 @@ test_truth_tracking_kalman[odd-0.0]__trackstates_kf.root: df4d48bbaae36524e8fd45
 test_truth_tracking_kalman[odd-0.0]__tracksummary_kf.root: 2da89eb48ccf5f14fcdbd8cbcac3c1a7e6cfb46150b6836b1c4a62a09263f941
 test_truth_tracking_kalman[odd-1000.0]__trackstates_kf.root: cd19f0a338637c49ecf4a6e1ac744e56c172f718d73a7daaca82b94d8be5d6ca
 test_truth_tracking_kalman[odd-1000.0]__tracksummary_kf.root: a4101349dec21ed3c68d798869e5493396918a5cdfd0d645ffb259ce9ec72d61
-test_strip_spacepoints[odd]__strip_spacepoints.root: bfc72d8fff76f0af305134bcdb09f0a897a4853bff9ed453be5d3a4294f1d191
+test_strip_space_points[odd]__strip_spacepoints.root: bfc72d8fff76f0af305134bcdb09f0a897a4853bff9ed453be5d3a4294f1d191

Python/Examples/tests/test_examples.py

@@ -1332,11 +1332,11 @@ def test_gnn_module_map(tmp_path, assert_root_hash, backend, hardware):
 
 
 @pytest.mark.odd
-def test_strip_spacepoints(detector_config, field, tmp_path, assert_root_hash):
+def test_strip_space_points(detector_config, field, tmp_path, assert_root_hash):
     if detector_config.name == "generic":
         pytest.skip("No strip space point formation for the generic detector currently")
 
-    from strip_spacepoints import createStripSpacePoints
+    from strip_space_points import createStripSpacePoints
 
     s = Sequencer(events=20, numThreads=-1)
 

Tests/UnitTests/Core/EventData/SpacePointContainerEdmTests.cpp

@@ -78,7 +78,7 @@ class Adapter {
 
 BOOST_AUTO_TEST_SUITE(EventDataSuite)
 
-BOOST_AUTO_TEST_CASE(spacepoint_container_edm_traits) {
+BOOST_AUTO_TEST_CASE(space_point_container_edm_traits) {
   using adapter_t = Adapter;
   using container_t = SpacePointContainer<adapter_t, detail::RefHolder>;
   using proxy_t = SpacePointProxy<container_t>;
@@ -93,7 +93,7 @@ BOOST_AUTO_TEST_CASE(spacepoint_container_edm_traits) {
                    std::random_access_iterator_tag>);
 }
 
-BOOST_AUTO_TEST_CASE(spacepoint_container_edm_constructors) {
+BOOST_AUTO_TEST_CASE(space_point_container_edm_constructors) {
   std::size_t nExternalPoints = 10;
   SpacePointCollection externalCollection(nExternalPoints);
 
@@ -111,7 +111,7 @@ BOOST_AUTO_TEST_CASE(spacepoint_container_edm_constructors) {
   BOOST_CHECK_EQUAL(spContainerVal.size(), nExternalPoints);
 }
 
-BOOST_AUTO_TEST_CASE(spacepoint_container_edm_functionalities) {
+BOOST_AUTO_TEST_CASE(space_point_container_edm_functionalities) {
   std::size_t nExternalPoints = 100;
   SpacePointCollection externalCollection;
   externalCollection.reserve(nExternalPoints);

Tests/UnitTests/Core/Vertexing/HoughVertexFinder2Tests.cpp

@@ -97,7 +97,7 @@ BOOST_AUTO_TEST_CASE(hough_vertex_finder_small_test) {
   BOOST_CHECK(vtxFound);
 }
 
-/// @brief Unit test for HoughVertexFinder2. Generates real-looking sets of the spacepoints, then finds a vertex, and then verifies the reconstructed vertex is actually near the original one
+/// @brief Unit test for HoughVertexFinder2. Generates real-looking sets of the space points, then finds a vertex, and then verifies the reconstructed vertex is actually near the original one
 BOOST_AUTO_TEST_CASE(hough_vertex_finder_full_test) {
   HoughVertexFinder2::Config houghVtxCfg;
   houghVtxCfg.targetSPs = 1000;
@@ -179,12 +179,12 @@ BOOST_AUTO_TEST_CASE(hough_vertex_finder_full_test) {
   BOOST_CHECK_EQUAL(vtxFound, nEvents);
 }
 
-/// @brief Unit test for HoughVertexFinder2. Provides no input spacepoints
+/// @brief Unit test for HoughVertexFinder2. Provides no input space points
 BOOST_AUTO_TEST_CASE(hough_vertex_finder_empty_test) {
   HoughVertexFinder2::Config houghVtxCfg;
   HoughVertexFinder2 houghVertexFinder(std::move(houghVtxCfg));
 
-  // no input spacepoints
+  // no input space points
   SpacePointContainer2 inputSpacePoints(
       SpacePointColumns::X | SpacePointColumns::Y | SpacePointColumns::Z);
 
@@ -198,13 +198,13 @@ BOOST_AUTO_TEST_CASE(hough_vertex_finder_empty_test) {
   BOOST_CHECK(!vtxFound);
 }
 
-/// @brief Unit test for HoughVertexFinder2. Does not provides enough spacepoints
+/// @brief Unit test for HoughVertexFinder2. Does not provides enough space points
 BOOST_AUTO_TEST_CASE(hough_vertex_finder_insufficient_test) {
   HoughVertexFinder2::Config houghVtxCfg;
   houghVtxCfg.targetSPs = 1000;
   houghVtxCfg.minAbsEta = 0.3;
   houghVtxCfg.maxAbsEta = 3.0;
-  houghVtxCfg.minHits = 3;  // requires 3 spacepoints per track
+  houghVtxCfg.minHits = 3;  // requires 3 space points per track
   houghVtxCfg.fillNeighbours = 0;
   houghVtxCfg.absEtaRanges = std::vector<double>({3.0});
   houghVtxCfg.absEtaFractions = std::vector<double>({1.0});
@@ -219,7 +219,7 @@ BOOST_AUTO_TEST_CASE(hough_vertex_finder_insufficient_test) {
 
   HoughVertexFinder2 houghVertexFinder(std::move(houghVtxCfg));
 
-  // only 2 spacepoints per track provided
+  // only 2 space points per track provided
   std::vector<std::vector<double>> positions = {
       {10., 0., 25.},   {20., 0., 30.},     // track 1
       {0., 5., 19.},    {0., 10., 18.},     // track 2