Fix: fix linter warnings

Author: ariedel-cern

PWGCF/Femto/Core/femtoUtils.h

@@ -18,6 +18,7 @@
 
 #include "Common/Core/TableHelper.h"
 
+#include "CommonConstants/MathConstants.h"
 #include "CommonConstants/PhysicsConstants.h"
 #include "Framework/InitContext.h"
 
@@ -136,14 +137,15 @@ float qn(T const& col)
 /// Recalculate pT for Kinks (Sigmas) using kinematic constraints
 inline float calcPtnew(float pxMother, float pyMother, float pzMother, float pxDaughter, float pyDaughter, float pzDaughter)
 {
+  float almost0 = 1e-6f;
   // Particle masses in GeV/c^2
-  const float massPion = 0.13957f;
-  const float massNeutron = 0.93957f;
-  const float massSigmaMinus = 1.19745f;
+  auto massPion = o2::constants::physics::MassPionCharged;
+  auto massNeutron = o2::constants::physics::MassNeutron;
+  auto massSigmaMinus = o2::constants::physics::MassSigmaMinus;
 
   // Calculate mother momentum and direction versor
   float pMother = std::sqrt(pxMother * pxMother + pyMother * pyMother + pzMother * pzMother);
-  if (pMother < 1e-6f)
+  if (pMother < almost0)
     return -999.f;
 
   float versorX = pxMother / pMother;
@@ -154,39 +156,39 @@ inline float calcPtnew(float pxMother, float pyMother, float pzMother, float pxD
   float ePi = std::sqrt(massPion * massPion + pxDaughter * pxDaughter + pyDaughter * pyDaughter + pzDaughter * pzDaughter);
 
   // Scalar product of versor with daughter momentum
-  float a = versorX * pxDaughter + versorY * pyDaughter + versorZ * pzDaughter;
+  float scalarProduct = versorX * pxDaughter + versorY * pyDaughter + versorZ * pzDaughter;
 
   // Solve quadratic equation for momentum magnitude
-  float K = massSigmaMinus * massSigmaMinus + massPion * massPion - massNeutron * massNeutron;
-  float A = 4.f * (ePi * ePi - a * a);
-  float B = -4.f * a * K;
-  float C = 4.f * ePi * ePi * massSigmaMinus * massSigmaMinus - K * K;
+  float k = massSigmaMinus * massSigmaMinus + massPion * massPion - massNeutron * massNeutron;
+  float a = 4.f * (ePi * ePi - scalarProduct * scalarProduct);
+  float b = -4.f * scalarProduct * k;
+  float c = 4.f * ePi * ePi * massSigmaMinus * massSigmaMinus - k * k;
 
-  if (std::abs(A) < 1e-6f)
+  if (std::abs(a) < almost0)
     return -999.f;
 
-  float D = B * B - 4.f * A * C;
-  if (D < 0.f)
+  float d = b * b - 4.f * a * c;
+  if (d < 0.f)
     return -999.f;
 
-  float sqrtD = std::sqrt(D);
-  float P1 = (-B + sqrtD) / (2.f * A);
-  float P2 = (-B - sqrtD) / (2.f * A);
+  float sqrtD = std::sqrt(d);
+  float p1 = (-b + sqrtD) / (2.f * a);
+  float p2 = (-b - sqrtD) / (2.f * a);
 
   // Pick physical solution: prefer P2 if positive, otherwise P1
-  if (P2 < 0.f && P1 < 0.f)
+  if (p2 < 0.f && p1 < 0.f)
     return -999.f;
-  if (P2 < 0.f)
-    return P1;
+  if (p2 < 0.f)
+    return p1;
 
   // Choose solution closest to original momentum
-  float p1Diff = std::abs(P1 - pMother);
-  float p2Diff = std::abs(P2 - pMother);
-  float P = (p1Diff < p2Diff) ? P1 : P2;
+  float p1Diff = std::abs(p1 - pMother);
+  float p2Diff = std::abs(p2 - pMother);
+  float p = (p1Diff < p2Diff) ? p1 : p2;
 
   // Calculate pT from recalibrated momentum
-  float pxS = versorX * P;
-  float pyS = versorY * P;
+  float pxS = versorX * p;
+  float pyS = versorY * p;
   return std::sqrt(pxS * pxS + pyS * pyS);
 }