ITS: try to optimize math+utils

Author: f3sch

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

@@ -16,6 +16,7 @@
 #ifndef O2_ITS_TRACKING_MATHUTILS_H_
 #define O2_ITS_TRACKING_MATHUTILS_H_
 
+#include <cmath>
 #include "CommonConstants/MathConstants.h"
 #include "MathUtils/Utils.h"
 #include "GPUCommonMath.h"
@@ -24,38 +25,34 @@
 namespace o2::its::math_utils
 {
 
-GPUhdi() float computePhi(const float x, const float y)
+GPUhdi() float computePhi(float x, float y)
 {
   return o2::math_utils::fastATan2(-y, -x) + o2::constants::math::PI;
 }
 
-GPUhdi() float hypot(const float x, const float y)
+GPUhdi() constexpr float hypot(float x, float y)
 {
-  return o2::gpu::CAMath::Sqrt(x * x + y * y);
+  return o2::gpu::CAMath::Hypot(x, y);
 }
 
-GPUhdi() constexpr float getNormalizedPhi(const float phi)
+GPUhdi() constexpr float getNormalizedPhi(float phi)
 {
-  return (phi < 0) ? phi + o2::constants::math::TwoPI : (phi > o2::constants::math::TwoPI) ? phi - o2::constants::math::TwoPI
-                                                                                           : phi;
-}
-
-GPUhdi() constexpr float3 crossProduct(const float3& firstVector, const float3& secondVector)
-{
-  return float3{(firstVector.y * secondVector.z) - (firstVector.z * secondVector.y),
-                (firstVector.z * secondVector.x) - (firstVector.x * secondVector.z),
-                (firstVector.x * secondVector.y) - (firstVector.y * secondVector.x)};
+  phi -= o2::constants::math::TwoPI * std::floor(phi * (1.f / o2::constants::math::TwoPI));
+  return phi;
 }
 
 GPUhdi() float computeCurvature(float x1, float y1, float x2, float y2, float x3, float y3)
 {
   const float d = (x2 - x1) * (y3 - y2) - (x3 - x2) * (y2 - y1);
+  if (o2::gpu::CAMath::Abs(d) < o2::constants::math::Almost0) {
+    return 0.f;
+  }
   const float a =
     0.5f * ((y3 - y2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1) - (y2 - y1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2));
   const float b =
     0.5f * ((x2 - x1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2) - (x3 - x2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1));
-  const float den2 = (d * x1 - a) * (d * x1 - a) + (d * y1 - b) * (d * y1 - b);
-  return den2 > 0.f ? -1.f * d / o2::gpu::CAMath::Sqrt(den2) : 0.f;
+  const float den = o2::gpu::CAMath::Hypot(d * x1 - a, d * y1 - b);
+  return -d / den;
 }
 
 GPUhdi() float computeCurvatureCentreX(float x1, float y1, float x2, float y2, float x3, float y3)
@@ -67,18 +64,17 @@ GPUhdi() float computeCurvatureCentreX(float x1, float y1, float x2, float y2, f
     dx32 = x3 - x2;
   }
   float k1 = (y2 - y1) / dx21, k2 = (y3 - y2) / dx32;
-  return (k1 != k2) ? 0.5f * (k1 * k2 * (y1 - y3) + k2 * (x1 + x2) - k1 * (x2 + x3)) / (k2 - k1) : 1e5;
+  return (k1 != k2) ? 0.5f * (k1 * k2 * (y1 - y3) + k2 * (x1 + x2) - k1 * (x2 + x3)) / (k2 - k1) : 1e5f;
 }
 
 GPUhdi() float computeTanDipAngle(float x1, float y1, float x2, float y2, float z1, float z2)
 {
-  return (z1 - z2) / o2::gpu::CAMath::Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+  return (z1 - z2) / o2::gpu::CAMath::Hypot(x1 - x2, y1 - y2);
 }
 
 GPUhdi() float smallestAngleDifference(float a, float b)
 {
-  float diff = fmod(b - a + o2::constants::math::PI, o2::constants::math::TwoPI) - o2::constants::math::PI;
-  return (diff < -o2::constants::math::PI) ? diff + o2::constants::math::TwoPI : ((diff > o2::constants::math::PI) ? diff - o2::constants::math::TwoPI : diff);
+  return std::remainder(b - a, o2::constants::math::TwoPI);
 }
 
 GPUhdi() float Sq(float v)