Merge branch 'AliceO2Group:dev' into new_geometry

Author: pkurash

.github/workflows/clean-test.yml

@@ -27,6 +27,10 @@ name: Clean PR checks
         description: build/O2/fullCI_slc9
         type: boolean
         default: true
+      'check_build/O2/fullCI-slc10-x86':
+        description: build/O2/fullCI-slc10-x86
+        type: boolean
+        default: true
       # Off by default, unlike every other check here: the gpu pool is a single
       # worker and a gpu-test round is hours, so resetting this is a much bigger
       # ask than requeueing one of the twenty-odd slc9/slc10 builders. Tick it

Common/MathUtils/include/MathUtils/detail/basicMath.h

@@ -91,17 +91,36 @@ GPUdi() T log(T x)
   return o2::gpu::GPUCommonMath::Log(x);
 };
 
-#ifndef GPUCA_GPUCODE_DEVICE // Double overloads using std namespace not visible on GPU
+template <class T>
+GPUdi() T exp(T x)
+{
+  return o2::gpu::GPUCommonMath::Exp(x);
+};
+
+#if !defined(GPUCA_GPUCODE_DEVICE) || defined(__CUDACC__) || defined(__HIPCC__) // Double specialisations, not for OpenCL and Metal
 template <>
 GPUhdi() double copysign(double x, double y)
 {
-  return std::copysign(x, y);
+  return o2::gpu::GPUCommonMath::Copysignd(x, y);
 }
 template <>
 GPUhdi() double sqrt(double x)
 {
-  return std::sqrt(x);
+  return o2::gpu::GPUCommonMath::Sqrtd(x);
 };
+template <>
+GPUdi() double log(double x)
+{
+  return o2::gpu::GPUCommonMath::Logd(x);
+};
+template <>
+GPUdi() double exp(double x)
+{
+  return o2::gpu::GPUCommonMath::Expd(x);
+};
+#endif
+
+#ifndef GPUCA_GPUCODE_DEVICE // Double overloads using std namespace not visible on GPU
 GPUhdi() double abs(double x)
 {
   return std::abs(x);
@@ -120,11 +139,6 @@ GPUdi() bool finite(double x)
   return std::isfinite(x);
 #endif
 }
-template <>
-GPUdi() double log(double x)
-{
-  return std::log(x);
-};
 #endif
 
 } // namespace detail

Common/MathUtils/include/MathUtils/detail/trigonometric.h

@@ -299,7 +299,7 @@ GPUhdi() constexpr T fastATan2(T y, T x)
     if (xx < 0) { // p1 is in the range [Pi/4, 3*Pi/4]
       phi0 = Pi075;
       tan = y1 > T(0) ? -x1 / y1 : T(0); // yy is always >=0, hence y1>=0
-    } else { // p1 is in the range [-Pi/4, Pi/4]
+    } else {                             // p1 is in the range [-Pi/4, Pi/4]
       phi0 = Pi025;
       tan = x1 > T(0) ? y1 / x1 : T(0);
     }
@@ -376,41 +376,41 @@ GPUdi() double pi()
   return o2::constants::math::PI;
 }
 
-#ifndef GPUCA_GPUCODE_DEVICE
+#if !defined(GPUCA_GPUCODE_DEVICE) || defined(__CUDACC__) || defined(__HIPCC__) // Double specialisations, not for OpenCL and Metal
 template <>
 GPUdi() double tan(double x)
 {
-  return std::tan(x);
+  return o2::gpu::GPUCommonMath::Tand(x);
 };
 template <>
 GPUdi() double sin(double x)
 {
-  return std::sin(x);
+  return o2::gpu::GPUCommonMath::Sind(x);
 };
 template <>
 GPUdi() double atan2(double y, double x)
 {
-  return std::atan2(y, x);
+  return o2::gpu::GPUCommonMath::ATan2d(y, x);
 };
 template <>
 GPUdi() double atan(double x)
 {
-  return std::atan(x);
+  return o2::gpu::GPUCommonMath::ATand(x);
 };
 template <>
 GPUdi() double asin(double x)
 {
-  return std::asin(x);
+  return o2::gpu::GPUCommonMath::ASind(x);
 };
 template <>
 GPUdi() double acos(double x)
 {
-  return std::acos(x);
+  return o2::gpu::GPUCommonMath::ACosd(x);
 };
 template <>
 GPUdi() double cos(double x)
 {
-  return std::cos(x);
+  return o2::gpu::GPUCommonMath::Cosd(x);
 };
 #endif
 

DataFormats/Detectors/FIT/FV0/CMakeLists.txt

@@ -17,6 +17,7 @@ o2_add_library(DataFormatsFV0
           src/RawEventData.cxx
           src/CTF.cxx
           src/LookUpTable.cxx
+          src/FV0RecoConfig.cxx
   PUBLIC_LINK_LIBRARIES O2::FV0Base
                         O2::DataFormatsFIT
                         O2::SimulationDataFormat
@@ -35,4 +36,6 @@ o2_target_root_dictionary(DataFormatsFV0
           include/DataFormatsFV0/RecPoints.h
           include/DataFormatsFV0/RawEventData.h
           include/DataFormatsFV0/LookUpTable.h
-          include/DataFormatsFV0/CTF.h)
+          include/DataFormatsFV0/CTF.h
+          include/DataFormatsFV0/FV0RecoConfig.h
+)

DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/FV0RecoConfig.h

@@ -0,0 +1,37 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_FV0_RECO_PARAM
+#define ALICEO2_FV0_RECO_PARAM
+
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "DataFormatsFV0/ChannelData.h"
+
+namespace o2::fv0
+{
+struct FV0RecoConfig : o2::conf::ConfigurableParamHelper<FV0RecoConfig> {
+  double AmplitudeLowerThreshold = 24;      // only channels with amplitude higher will participate in calibration and collision time
+  double AmplitudeThresholdForMeanTime = 5; // Charge threshold, only above which the time is taken into account in calculating the mean time of all qualifying channels
+  double TimeUpperThreshold = 1000.0;       // only channels with time below will participate in calibration and collision time
+  uint8_t mValidPmInputFlagMask = static_cast<uint8_t>(~(1u << ChannelData::kNumberADC));
+  uint8_t mValidPmInputFlags = static_cast<uint8_t>((1u << ChannelData::kIsCFDinADCgate) | (1u << ChannelData::kIsEventInTVDC));
+
+  bool areChannelDataFlagsGood(uint8_t flags) const
+  {
+    return (flags & mValidPmInputFlagMask) == mValidPmInputFlags;
+  }
+  O2ParamDef(FV0RecoConfig, "FV0RecoConfig");
+  ClassDefNV(FV0RecoConfig, 1);
+};
+
+} // namespace o2::fv0
+
+#endif

DataFormats/Detectors/FIT/FV0/src/DataFormatsFV0LinkDef.h

@@ -40,4 +40,6 @@
 #pragma link C++ class o2::fv0::FV0CalibrationInfoObject + ;
 #pragma link C++ class o2::fv0::FV0ChannelTimeCalibrationObject + ;
 
+#pragma link C++ class o2::fv0::FV0RecoConfig + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::fv0::FV0RecoConfig> + ;
 #endif

DataFormats/Detectors/FIT/FV0/src/FV0RecoConfig.cxx

@@ -0,0 +1,15 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "DataFormatsFV0/FV0RecoConfig.h"
+
+using namespace o2::fv0;
+O2ParamImpl(FV0RecoConfig);

DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/TrackCosmicsExtended.h

@@ -110,16 +110,20 @@ struct TrackCosmicsExtended {
                                                ///< approach to the beam line; valid if chi2MatchPolished >= 0
   float chi2MatchPolished = -1.f;              ///< chi2 of the polished bottom and top halves at the closest approach (< 0: not polished)
   o2::MCCompLabel label{};                     ///< MC label of the cosmic (MC only)
+  float tpcOccBef = -1.f;                      ///< TPC clusters in the orbit before the time of the cosmic (TOF time if hasTOFTime(), else the matcher's),
+                                               ///< from the TPC occupancy map (-1: no map, or the orbit is not fully inside the TF)
+  float tpcOccAft = -1.f;                      ///< same for the orbit after the time of the cosmic, i.e. while its clusters drift
 
   bool hasTOFTime() const { return scoreTOFPair >= 0.f; } ///< a HitTOFFlight pair gave the cosmic its time timeTOFMUS
-  ClassDefNV(TrackCosmicsExtended, 1);
+  ClassDefNV(TrackCosmicsExtended, 2);
 };
 
-/// per-TF quantities of the TPC transformation used in the reconstruction
+/// per-TF quantities: the TPC transformation used in the reconstruction and the TPC occupancy
 struct CosmicsTFInfo {
-  float vDrift = 0.f; ///< drift velocity of the transformation [cm/time bin]
-  float t0 = 0.f;     ///< time offset of the transformation [time bins]
-  ClassDefNV(CosmicsTFInfo, 1);
+  float vDrift = 0.f;  ///< drift velocity of the transformation [cm/time bin]
+  float t0 = 0.f;      ///< time offset of the transformation [time bins]
+  float tpcOcc = -1.f; ///< TPC clusters per orbit, average of the TF (TPC occupancy map) (< 0: no map)
+  ClassDefNV(CosmicsTFInfo, 2);
 };
 
 } // namespace o2::dataformats

DataFormats/Reconstruction/include/ReconstructionDataFormats/BaseCluster.h

@@ -34,9 +34,9 @@ class BaseCluster
 {
  private:
   math_utils::Point3D<T> mPos; // cartesian position
-  T mSigmaY2;                  // error in Y direction (usually rphi)
-  T mSigmaZ2;                  // error in Z direction (usually Z)
-  T mSigmaYZ;                  // non-diagonal term of error matrix
+  T mSigmaY2 = 0;              // error in Y direction (usually rphi)
+  T mSigmaZ2 = 0;              // error in Z direction (usually Z)
+  T mSigmaYZ = 0;              // non-diagonal term of error matrix
   std::uint16_t mSensorID = 0; // the sensor id
   std::int8_t mCount = 0;      // user field reserved for counting
   std::uint8_t mBits = 0;      // user field reserved for bit flags

DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h

@@ -402,7 +402,7 @@ GPUdi() auto TrackParametrization<value_T>::getR2() const -> value_t
 template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getR() const -> value_t
 {
-  return gpu::CAMath::Sqrt(getR2());
+  return math_utils::detail::sqrt<value_t>(getR2());
 }
 
 //____________________________________________________________
@@ -441,7 +441,7 @@ GPUdi() auto TrackParametrization<value_T>::getCsp2() const -> value_t
 template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getCsp() const -> value_t
 {
-  return gpu::CAMath::Sqrt(getCsp2());
+  return math_utils::detail::sqrt<value_t>(getCsp2());
 }
 
 //____________________________________________________________
@@ -518,7 +518,7 @@ GPUdi() void TrackParametrization<value_T>::getCircleParamsLoc(value_t bz, o2::m
   constexpr value_t MinSagitta = 0.01f, TPCMidR = 160.f, MinCurv = 8 * MinSagitta / (TPCMidR * TPCMidR);
   if (gpu::CAMath::Abs(c.rC) > MinCurv) {
     c.rC = 1.f / getCurvature(bz);
-    value_t sn = getSnp(), cs = gpu::CAMath::Sqrt((1.f - sn) * (1.f + sn));
+    value_t sn = getSnp(), cs = math_utils::detail::sqrt<value_t>((1.f - sn) * (1.f + sn));
     c.xC = getX() - sn * c.rC; // center in tracking
     c.yC = getY() + cs * c.rC; // frame. Note: r is signed!!!
     c.rC = gpu::CAMath::Abs(c.rC);
@@ -546,7 +546,7 @@ GPUdi() void TrackParametrization<value_T>::getLineParams(o2::math_utils::Interv
   // get line parameterization as { x = x0 + xSlp*t, y = y0 + ySlp*t }
   o2::math_utils::detail::sincos(getAlpha(), sna, csa);
   o2::math_utils::detail::rotateZ<value_t>(getX(), getY(), ln.getX0(), ln.getY0(), sna, csa); // reference point in global frame
-  value_t snp = getSnp(), csp = gpu::CAMath::Sqrt((1.f - snp) * (1.f + snp));
+  value_t snp = getSnp(), csp = math_utils::detail::sqrt<value_t>((1.f - snp) * (1.f + snp));
   ln.setDX(csp * csa - snp * sna);
   ln.setDY(snp * csa + csp * sna);
 }
@@ -577,7 +577,7 @@ template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getPhi() const -> value_t
 {
   // track pt direction phi (in 0:2pi range)
-  value_t phi = gpu::CAMath::ASin(getSnp()) + getAlpha();
+  value_t phi = math_utils::detail::asin<value_t>(getSnp()) + getAlpha();
   math_utils::detail::bringTo02Pi<value_t>(phi);
   return phi;
 }
@@ -587,7 +587,7 @@ template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getPhiPos() const -> value_t
 {
   // angle of track position (in -pi:pi range)
-  value_t phi = gpu::CAMath::ATan2(getY(), getX()) + getAlpha();
+  value_t phi = math_utils::detail::atan2<value_t>(getY(), getX()) + getAlpha();
   math_utils::detail::bringTo02Pi<value_t>(phi);
   return phi;
 }
@@ -638,7 +638,7 @@ template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getPInv() const -> value_t
 {
   // return the inverted track momentum
-  return getPtInv() / gpu::CAMath::Sqrt(1.f + getTgl() * getTgl()); // getPtInv() is protected against being 0, full charge accounted
+  return getPtInv() / math_utils::detail::sqrt<value_t>(1.f + getTgl() * getTgl()); // getPtInv() is protected against being 0, full charge accounted
 }
 
 //____________________________________________________________
@@ -662,7 +662,7 @@ template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getE() const -> value_t
 {
   // return the track energy
-  return gpu::CAMath::Sqrt(getE2());
+  return math_utils::detail::sqrt<value_t>(getE2());
 }
 
 //____________________________________________________________
@@ -677,14 +677,14 @@ GPUdi() auto TrackParametrization<value_T>::getPt() const -> value_t
 template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getTheta() const -> value_t
 {
-  return constants::math::PIHalf - gpu::CAMath::ATan(mP[3]);
+  return constants::math::PIHalf - math_utils::detail::atan<value_t>(mP[3]);
 }
 
 //____________________________________________________________
 template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getEta() const -> value_t
 {
-  return -gpu::CAMath::Log(gpu::CAMath::Tan(0.5f * getTheta()));
+  return -math_utils::detail::log<value_t>(math_utils::detail::tan<value_t>(0.5f * getTheta()));
 }
 
 //_______________________________________________________