ITS: ClusterLines simplify math

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

Author: f3sch

Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h

@@ -130,47 +130,38 @@ inline float Line::getDistanceFromPoint(const Line& line, const std::array<float
 
 GPUhdi() float Line::getDistanceFromPoint(const Line& line, const float point[3])
 {
-  float DCASquared{0};
-  float cdelta{0};
-  for (int i{0}; i < 3; ++i) {
-    cdelta -= line.cosinesDirector[i] * (line.originPoint[i] - point[i]);
-  }
-  for (int i{0}; i < 3; ++i) {
-    DCASquared += (line.originPoint[i] - point[i] + line.cosinesDirector[i] * cdelta) *
-                  (line.originPoint[i] - point[i] + line.cosinesDirector[i] * cdelta);
-  }
-  return o2::gpu::CAMath::Sqrt(DCASquared);
+  const float dx = point[0] - line.originPoint[0];
+  const float dy = point[1] - line.originPoint[1];
+  const float dz = point[2] - line.originPoint[2];
+  const float d = (dx * line.cosinesDirector[0]) + (dy * line.cosinesDirector[1]) + (dz * line.cosinesDirector[2]);
+
+  const float vx = dx - (d * line.cosinesDirector[0]);
+  const float vy = dy - (d * line.cosinesDirector[1]);
+  const float vz = dz - (d * line.cosinesDirector[2]);
+
+  return o2::gpu::CAMath::Hypot(vx, vy, vz);
 }
 
 GPUhdi() float Line::getDCA(const Line& firstLine, const Line& secondLine, const float precision)
 {
-  float normalVector[3];
-  normalVector[0] = firstLine.cosinesDirector[1] * secondLine.cosinesDirector[2] -
-                    firstLine.cosinesDirector[2] * secondLine.cosinesDirector[1];
-  normalVector[1] = -firstLine.cosinesDirector[0] * secondLine.cosinesDirector[2] +
-                    firstLine.cosinesDirector[2] * secondLine.cosinesDirector[0];
-  normalVector[2] = firstLine.cosinesDirector[0] * secondLine.cosinesDirector[1] -
-                    firstLine.cosinesDirector[1] * secondLine.cosinesDirector[0];
-
-  float norm{0.f}, distance{0.f};
-  for (int i{0}; i < 3; ++i) {
-    norm += normalVector[i] * normalVector[i];
-    distance += (secondLine.originPoint[i] - firstLine.originPoint[i]) * normalVector[i];
-  }
-  if (norm > precision) {
-    return o2::gpu::CAMath::Abs(distance / o2::gpu::CAMath::Sqrt(norm));
-  } else {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-    float stdOriginPoint[3];
-    for (int i{0}; i < 3; ++i) {
-      stdOriginPoint[i] = secondLine.originPoint[1];
-    }
-#else
-    std::array<float, 3> stdOriginPoint = {};
-    std::copy_n(secondLine.originPoint, 3, stdOriginPoint.begin());
-#endif
-    return getDistanceFromPoint(firstLine, stdOriginPoint);
+  const float nx = (firstLine.cosinesDirector[1] * secondLine.cosinesDirector[2]) -
+                   (firstLine.cosinesDirector[2] * secondLine.cosinesDirector[1]);
+  const float ny = -(firstLine.cosinesDirector[0] * secondLine.cosinesDirector[2]) +
+                   (firstLine.cosinesDirector[2] * secondLine.cosinesDirector[0]);
+  const float nz = (firstLine.cosinesDirector[0] * secondLine.cosinesDirector[1]) -
+                   (firstLine.cosinesDirector[1] * secondLine.cosinesDirector[0]);
+  const float norm2 = (nx * nx) + (ny * ny) + (nz * nz);
+
+  if (norm2 <= precision * precision) {
+    return getDistanceFromPoint(firstLine, secondLine.originPoint);
   }
+
+  const float dx = secondLine.originPoint[0] - firstLine.originPoint[0];
+  const float dy = secondLine.originPoint[1] - firstLine.originPoint[1];
+  const float dz = secondLine.originPoint[2] - firstLine.originPoint[2];
+  const float triple = (dx * nx) + (dy * ny) + (dz * nz);
+
+  return o2::gpu::CAMath::Abs(triple) / o2::gpu::CAMath::Sqrt(norm2);
 }
 
 GPUhdi() void Line::getDCAComponents(const Line& line, const float point[3], float destArray[6])