Merge branch 'AliceO2Group:dev' into new-detector4

Author: pkurash

Common/DCAFitter/include/DCAFitter/HelixHelper.h

@@ -63,9 +63,10 @@ struct CrossInfo {
   {
     const auto& trcA = trax0.rC > trax1.rC ? trax0 : trax1; // designate the largest circle as A
     const auto& trcB = trax0.rC > trax1.rC ? trax1 : trax0;
+    nDCA = 0;
     float xDist = trcB.xC - trcA.xC, yDist = trcB.yC - trcA.yC;
     float dist2 = xDist * xDist + yDist * yDist, dist = o2::gpu::GPUCommonMath::Sqrt(dist2), rsum = trcA.rC + trcB.rC;
-    if (o2::gpu::GPUCommonMath::Sqrt(dist) < 1e-12) {
+    if (dist < 1e-12) {
       return nDCA; // circles are concentric?
     }
     if (dist > rsum) { // circles don't touch, chose a point in between
@@ -75,9 +76,13 @@ struct CrossInfo {
         return nDCA;
       }
       notTouchingXY(dist, xDist, yDist, trcA, trcB.rC, isCollinear);
-    } else if (dist + trcB.rC < trcA.rC) { // the small circle is nestled into large one w/o touching
-      // select the point of closest approach of 2 circles
-      notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
+    } else if (auto dfr = dist + trcB.rC - trcA.rC; dfr < 0.) { // the small circle is nestled into large one w/o touching
+      if (dfr > -maxDistXY) {
+        // select the point of closest approach of 2 circles
+        notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
+      } else {
+        return nDCA;
+      }
     } else { // 2 intersection points
       if (isCollinear) {
         /// collinear tracks, e.g. electrons from photon conversion
@@ -89,7 +94,7 @@ struct CrossInfo {
         xDCA[0] = r2_r * trcA.xC + r1_r * trcB.xC;
         yDCA[0] = r2_r * trcA.yC + r1_r * trcB.yC;
         nDCA = 1;
-      } else if (o2::gpu::GPUCommonMath::Sqrt(xDist) < o2::gpu::GPUCommonMath::Sqrt(yDist)) {
+      } else if (o2::gpu::GPUCommonMath::Abs(xDist) < o2::gpu::GPUCommonMath::Abs(yDist)) {
         // to simplify calculations, we move to new frame x->x+Xc0, y->y+Yc0, so that
         // the 1st one is centered in origin
         float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * yDist), b = -xDist / yDist, ab = a * b, bb = b * b;
@@ -167,7 +172,7 @@ struct CrossInfo {
     ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
     ///  zL(t) = zL + t Kz;  Kz = tgl / csp
     ///  Note that Kx^2 + Ky^2 + Kz^2 = (1+tgl^2) / csp^2
-
+    nDCA = 0;
     float dx = trax1.xC - trax0.xC; // for straight line TrackAuxPar stores lab coordinates at referene point!!!
     float dy = trax1.yC - trax0.yC; //
     float dz = tr1.getZ() - tr0.getZ();

Common/Utils/include/CommonUtils/EnumFlags.h

@@ -160,8 +160,9 @@ struct FlagsHelper final {
   static constexpr auto Max_v{Values.back()};                                                          // Enum last entry
   static constexpr auto Min_u_v{static_cast<size_t>(Min_v)};                                           // Enum first entry as size_t
   static constexpr auto Max_u_v{static_cast<size_t>(Max_v)};                                           // Enum last entry as size_t
-  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); }         // Is the enum continuous
-  static constexpr auto MaxRep{((1 << (Max_u_v - Min_u_v + 1)) - 1) << Min_u_v};                       // largest representable value
+  static_assert(Max_u_v < std::numeric_limits<U>::digits, "Max Bit is beyond allow range defered from underlying type");
+  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); }                             // Is the enum continuous
+  static constexpr auto MaxRep{((1ULL << (static_cast<unsigned long long>(Max_u_v - Min_u_v) + 1ULL)) - 1ULL) << Min_u_v}; // largest representable value
 
   template <E e>
   static constexpr std::string_view getName()

Common/Utils/test/testEnumFlags.cxx

@@ -28,6 +28,46 @@ enum class TestEnum : uint8_t {
   Bit5VeryLongName,
 };
 
+// Very long enum
+// to test that it works beyond 32 bits
+enum class TestEnumLong : uint64_t {
+  Bit1,
+  Bit2,
+  Bit3,
+  Bit4,
+  Bit5,
+  Bit6,
+  Bit7,
+  Bit8,
+  Bit9,
+  Bit10,
+  Bit11,
+  Bit12,
+  Bit13,
+  Bit14,
+  Bit15,
+  Bit16,
+  Bit17,
+  Bit18,
+  Bit19,
+  Bit20,
+  Bit21,
+  Bit22,
+  Bit23,
+  Bit24,
+  Bit25,
+  Bit26,
+  Bit27,
+  Bit28,
+  Bit29,
+  Bit30,
+  Bit31,
+  Bit32,
+  Bit33,
+  Bit34,
+  // ...
+};
+
 BOOST_AUTO_TEST_CASE(Flags_test)
 {
   using EFlags = o2::utils::EnumFlags<TestEnum>;
@@ -257,4 +297,11 @@ BOOST_AUTO_TEST_CASE(Flags_test)
     EFlags flags3{TestEnum::Bit4};
     BOOST_CHECK(!flags1.contains(flags3)); // flags1 does not contain flags3
   }
+
+  {
+    // Test compilation using an enum with more than 32 bits
+    o2::utils::EnumFlags<TestEnumLong> test;
+    test.set("Bit32");
+    BOOST_CHECK(test.test(TestEnumLong::Bit32));
+  }
 }

Detectors/CTF/test/test_ctf_io_cpv.cxx

@@ -28,6 +28,7 @@
 #include <TRandom.h>
 #include <TStopwatch.h>
 #include <TSystem.h>
+#include <TMath.h>
 #include <cstring>
 
 using namespace o2::cpv;