refactor: transformCoordinates methods without InternalSpacePoint cla…

…ss (#1173)

Adding `transformCoordinates` functions that does not rely only on `InternalSpacePoint`. These methods will accept any space point format and require the user to define a function for retrieving coordinate and covariance values (i.e. `std::function<std::array<float, 6>(const external_spacepoint_t&)>`). This will allow users to use it externally to ACTS.

This does not remove the previous `transformCoordinates` functions in order to be backward compatible. However, they are adapted to use these new implementations.

Core/include/Acts/Seeding/SeedFinderUtils.hpp

@@ -40,6 +40,11 @@ LinCircle transformCoordinates(InternalSpacePoint<external_spacepoint_t>& sp,
                                InternalSpacePoint<external_spacepoint_t>& spM,
                                bool bottom);
 
+template <typename external_spacepoint_t, typename callable_t>
+LinCircle transformCoordinates(external_spacepoint_t& sp,
+                               external_spacepoint_t& spM, bool bottom,
+                               callable_t&& extractFunction);
+
 /// @brief Transform a vector of spacepoints to u-v space circles with respect
 /// to a given middle spacepoint.
 ///
@@ -52,9 +57,16 @@ LinCircle transformCoordinates(InternalSpacePoint<external_spacepoint_t>& sp,
 /// @param[out] linCircleVec The output vector to write to.
 template <typename external_spacepoint_t>
 void transformCoordinates(
-    const std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
+    std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     bool enableCutsForSortedSP, std::vector<LinCircle>& linCircleVec);
+
+template <typename external_spacepoint_t, typename callable_t>
+void transformCoordinates(std::vector<external_spacepoint_t*>& vec,
+                          external_spacepoint_t& spM, bool bottom,
+                          bool enableCutsForSortedSP,
+                          std::vector<LinCircle>& linCircleVec,
+                          callable_t&& extractFunction);
 }  // namespace Acts
 
 #include "Acts/Seeding/SeedFinderUtils.ipp"

Core/include/Acts/Seeding/SeedFinderUtils.ipp

@@ -11,21 +11,35 @@ template <typename external_spacepoint_t>
 LinCircle transformCoordinates(InternalSpacePoint<external_spacepoint_t>& sp,
                                InternalSpacePoint<external_spacepoint_t>& spM,
                                bool bottom) {
+  auto extractFunction =
+      [](const InternalSpacePoint<external_spacepoint_t>& obj)
+      -> std::array<float, 6> {
+    std::array<float, 6> output{obj.x(),      obj.y(),         obj.z(),
+                                obj.radius(), obj.varianceR(), obj.varianceZ()};
+    return output;
+  };
+
+  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(
+      sp, spM, bottom, extractFunction);
+}
+
+template <typename external_spacepoint_t, typename callable_t>
+LinCircle transformCoordinates(external_spacepoint_t& sp,
+                               external_spacepoint_t& spM, bool bottom,
+                               callable_t&& extractFunction) {
   // The computation inside this function is exactly identical to that in the
   // vectorized version of this function, except that it operates on a single
   // spacepoint. Please see the other version of this function for more
   // detailed comments.
-  float xM = spM.x();
-  float yM = spM.y();
-  float zM = spM.z();
-  float rM = spM.radius();
-  float varianceZM = spM.varianceZ();
-  float varianceRM = spM.varianceR();
+
+  auto [xM, yM, zM, rM, varianceRM, varianceZM] = extractFunction(spM);
+  auto [xSP, ySP, zSP, rSP, varianceRSP, varianceZSP] = extractFunction(sp);
+
   float cosPhiM = xM / rM;
   float sinPhiM = yM / rM;
-  float deltaX = sp.x() - xM;
-  float deltaY = sp.y() - yM;
-  float deltaZ = sp.z() - zM;
+  float deltaX = xSP - xM;
+  float deltaY = ySP - yM;
+  float deltaZ = zSP - zM;
   float x = deltaX * cosPhiM + deltaY * sinPhiM;
   float y = deltaY * cosPhiM - deltaX * sinPhiM;
   float iDeltaR2 = 1. / (deltaX * deltaX + deltaY * deltaY);
@@ -38,8 +52,8 @@ LinCircle transformCoordinates(InternalSpacePoint<external_spacepoint_t>& sp,
   l.iDeltaR = iDeltaR;
   l.U = x * iDeltaR2;
   l.V = y * iDeltaR2;
-  l.Er = ((varianceZM + sp.varianceZ()) +
-          (cot_theta * cot_theta) * (varianceRM + sp.varianceR())) *
+  l.Er = ((varianceZM + varianceZSP) +
+          (cot_theta * cot_theta) * (varianceRM + varianceRSP)) *
          iDeltaR2;
   return l;
 }
@@ -49,18 +63,34 @@ void transformCoordinates(
     std::vector<InternalSpacePoint<external_spacepoint_t>*>& vec,
     InternalSpacePoint<external_spacepoint_t>& spM, bool bottom,
     bool enableCutsForSortedSP, std::vector<LinCircle>& linCircleVec) {
-  float xM = spM.x();
-  float yM = spM.y();
-  float zM = spM.z();
-  float rM = spM.radius();
-  float varianceZM = spM.varianceZ();
-  float varianceRM = spM.varianceR();
+  auto extractFunction =
+      [](const InternalSpacePoint<external_spacepoint_t>& obj)
+      -> std::array<float, 6> {
+    std::array<float, 6> output{obj.x(),      obj.y(),         obj.z(),
+                                obj.radius(), obj.varianceR(), obj.varianceZ()};
+    return output;
+  };
+
+  return transformCoordinates<InternalSpacePoint<external_spacepoint_t>>(
+      vec, spM, bottom, enableCutsForSortedSP, linCircleVec, extractFunction);
+}
+
+template <typename external_spacepoint_t, typename callable_t>
+void transformCoordinates(std::vector<external_spacepoint_t*>& vec,
+                          external_spacepoint_t& spM, bool bottom,
+                          bool enableCutsForSortedSP,
+                          std::vector<LinCircle>& linCircleVec,
+                          callable_t&& extractFunction) {
+  auto [xM, yM, zM, rM, varianceRM, varianceZM] = extractFunction(spM);
+
   float cosPhiM = xM / rM;
   float sinPhiM = yM / rM;
   for (auto sp : vec) {
-    float deltaX = sp->x() - xM;
-    float deltaY = sp->y() - yM;
-    float deltaZ = sp->z() - zM;
+    auto [xSP, ySP, zSP, rSP, varianceRSP, varianceZSP] = extractFunction(*sp);
+
+    float deltaX = xSP - xM;
+    float deltaY = ySP - yM;
+    float deltaZ = zSP - zM;
     // calculate projection fraction of spM->sp vector pointing in same
     // direction as
     // vector origin->spM (x) and projection fraction of spM->sp vector pointing
@@ -104,8 +134,7 @@ void transformCoordinates(
   // sort the SP in order of cotTheta
   if (enableCutsForSortedSP) {
     std::sort(vec.begin(), vec.end(),
-              [](InternalSpacePoint<external_spacepoint_t>* a,
-                 InternalSpacePoint<external_spacepoint_t>* b) -> bool {
+              [](external_spacepoint_t* a, external_spacepoint_t* b) -> bool {
                 return (a->cotTheta() < b->cotTheta());
               });
     std::sort(linCircleVec.begin(), linCircleVec.end(),