Merge branch 'master' into patch-14

.github/workflows/o2-linter.yml

@@ -24,6 +24,10 @@ jobs:
         run: |
           # Diff against the common ancestor of the source branch and the main branch.
           readarray -t files < <(git diff --diff-filter d --name-only origin/${{ env.MAIN_BRANCH }}...)
+          if [ ${#files[@]} -eq 0 ]; then
+              echo "::notice::No files to lint."
+              exit 0
+          fi
           [ ${{ github.event_name }} == 'pull_request' ] && options="-g"
           # shellcheck disable=SC2086 # Ignore unquoted options.
           python3 Scripts/o2_linter.py $options "${files[@]}"

Common/Core/RecoDecay.h

@@ -208,18 +208,23 @@ struct RecoDecay {
   /// Constrains angle to be within a range.
   /// \note Inspired by TVector2::Phi_0_2pi in ROOT.
   /// \param angle  angle
-  /// \param min  minimum of the range
-  /// \return value within [min, min + 2π).
+  /// \param minimum  minimum of the range
+  /// \param harmonic  harmonic number
+  /// \return value of angle within [minimum, minimum + 2π / harmonic).
   template <typename T, typename U = float>
-  static T constrainAngle(T angle, U min = 0.)
+  static T constrainAngle(T angle, U minimum = 0.0F, unsigned int harmonic = 1U)
   {
-    while (angle < min) {
-      angle += o2::constants::math::TwoPI;
+    auto period = o2::constants::math::TwoPI;
+    if (harmonic != 1U) {
+      period /= harmonic;
     }
-    while (angle >= min + o2::constants::math::TwoPI) {
-      angle -= o2::constants::math::TwoPI;
+    while (angle < minimum) {
+      angle += period;
     }
-    return (T)angle;
+    while (angle >= minimum + period) {
+      angle -= period;
+    }
+    return angle;
   }
 
   /// Calculates cosine of pointing angle.

Common/DataModel/Multiplicity.h

@@ -206,54 +206,42 @@ DECLARE_SOA_TABLE(PVMultZeqs, "AOD", "PVMULTZEQ", //! Multiplicity equalized for
 using MultZeqs = soa::Join<FV0MultZeqs, FT0MultZeqs, FDDMultZeqs, PVMultZeqs>;
 using MultZeq = MultZeqs::iterator;
 
-namespace multBC
+namespace mult
 {
-DECLARE_SOA_COLUMN(MultBCFT0A, multBCFT0A, float); //!
-DECLARE_SOA_COLUMN(MultBCFT0C, multBCFT0C, float); //!
-DECLARE_SOA_COLUMN(MultBCFV0A, multBCFV0A, float); //!
-DECLARE_SOA_COLUMN(MultBCFDDA, multBCFDDA, float); //!
-DECLARE_SOA_COLUMN(MultBCFDDC, multBCFDDC, float); //!
-
-DECLARE_SOA_COLUMN(MultBCZNA, multBCZNA, float);   //!
-DECLARE_SOA_COLUMN(MultBCZNC, multBCZNC, float);   //!
-DECLARE_SOA_COLUMN(MultBCZEM1, multBCZEM1, float); //!
-DECLARE_SOA_COLUMN(MultBCZEM2, multBCZEM2, float); //!
-DECLARE_SOA_COLUMN(MultBCZPA, multBCZPA, float);   //!
-DECLARE_SOA_COLUMN(MultBCZPC, multBCZPC, float);   //!
+// extra BC information
+DECLARE_SOA_COLUMN(MultTVX, multTVX, bool);                          //!
+DECLARE_SOA_COLUMN(MultFV0OrA, multFV0OrA, bool);                    //!
+DECLARE_SOA_COLUMN(MultV0triggerBits, multV0triggerBits, uint8_t);   //!
+DECLARE_SOA_COLUMN(MultT0triggerBits, multT0triggerBits, uint8_t);   //!
+DECLARE_SOA_COLUMN(MultFDDtriggerBits, multFDDtriggerBits, uint8_t); //!
+DECLARE_SOA_COLUMN(MultTriggerMask, multTriggerMask, uint64_t);      //! CTP trigger mask
+DECLARE_SOA_COLUMN(MultCollidingBC, multCollidingBC, bool);          //! CTP trigger mask
 
-DECLARE_SOA_COLUMN(MultBCTVX, multBCTVX, bool);                          //!
-DECLARE_SOA_COLUMN(MultBCFV0OrA, multBCFV0OrA, bool);                    //!
-DECLARE_SOA_COLUMN(MultBCV0triggerBits, multBCV0triggerBits, uint8_t);   //!
-DECLARE_SOA_COLUMN(MultBCT0triggerBits, multBCT0triggerBits, uint8_t);   //!
-DECLARE_SOA_COLUMN(MultBCFDDtriggerBits, multBCFDDtriggerBits, uint8_t); //!
-DECLARE_SOA_COLUMN(MultBCTriggerMask, multBCTriggerMask, uint64_t);      //! CTP trigger mask
-DECLARE_SOA_COLUMN(MultBCColliding, multBCColliding, bool);              //! CTP trigger mask
-
-DECLARE_SOA_COLUMN(MultBCFT0PosZ, multBCFT0PosZ, float);          //! Position along Z computed with the FT0 information within the BC
-DECLARE_SOA_COLUMN(MultBCFT0PosZValid, multBCFT0PosZValid, bool); //! Validity of the position along Z computed with the FT0 information within the BC
-
-} // namespace multBC
+DECLARE_SOA_COLUMN(MultFT0PosZ, multFT0PosZ, float);          //! Position along Z computed with the FT0 information within the BC
+DECLARE_SOA_COLUMN(MultFT0PosZValid, multFT0PosZValid, bool); //! Validity of the position along Z computed with the FT0 information
+} // namespace mult
 DECLARE_SOA_TABLE(MultBCs, "AOD", "MULTBC", //!
-                  multBC::MultBCFT0A,
-                  multBC::MultBCFT0C,
-                  multBC::MultBCFT0PosZ,
-                  multBC::MultBCFT0PosZValid,
-                  multBC::MultBCFV0A,
-                  multBC::MultBCFDDA,
-                  multBC::MultBCFDDC,
-                  multBC::MultBCZNA,
-                  multBC::MultBCZNC,
-                  multBC::MultBCZEM1,
-                  multBC::MultBCZEM2,
-                  multBC::MultBCZPA,
-                  multBC::MultBCZPC,
-                  multBC::MultBCTVX,
-                  multBC::MultBCFV0OrA,
-                  multBC::MultBCV0triggerBits,
-                  multBC::MultBCT0triggerBits,
-                  multBC::MultBCFDDtriggerBits,
-                  multBC::MultBCTriggerMask,
-                  multBC::MultBCColliding,
+                  mult::MultFT0A,
+                  mult::MultFT0C,
+                  mult::MultFT0PosZ,
+                  mult::MultFT0PosZValid,
+                  mult::MultFV0A,
+                  mult::MultFDDA,
+                  mult::MultFDDC,
+                  mult::MultZNA,
+                  mult::MultZNC,
+                  mult::MultZEM1,
+                  mult::MultZEM2,
+                  mult::MultZPA,
+                  mult::MultZPC,
+                  mult::MultTVX,
+                  mult::MultFV0OrA,
+                  mult::MultV0triggerBits,
+                  mult::MultT0triggerBits,
+                  mult::MultFDDtriggerBits,
+                  mult::MultTriggerMask,
+                  mult::MultCollidingBC,
+                  timestamp::Timestamp,
                   bc::Flags);
 using MultBC = MultBCs::iterator;
 

Common/DataModel/PIDResponseITS.h

@@ -81,6 +81,12 @@ struct ITSResponse {
     return (average * coslInv - exp) / resolution;
   };
 
+  template <o2::track::PID::ID id, typename T>
+  static float nSigmaITS(const T& track)
+  {
+    return nSigmaITS<id>(track.itsClusterSizes(), track.p(), track.eta());
+  }
+
   static void setParameters(float p0, float p1, float p2, float p0_Z2, float p1_Z2, float p2_Z2, float p0_res, float p1_res, float p2_res)
   {
     if (mIsInitialized) {

Common/TableProducer/Converters/CMakeLists.txt

@@ -83,3 +83,8 @@ o2physics_add_dpl_workflow(multmcextras-converter
                     SOURCES multMCExtrasConverter.cxx
                     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
                     COMPONENT_NAME Analysis)
+
+o2physics_add_dpl_workflow(trackqa-converter
+                    SOURCES trackQAConverter.cxx
+                    PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
+                    COMPONENT_NAME Analysis)

Common/TableProducer/Converters/trackQAConverter.cxx

@@ -0,0 +1,60 @@
+// 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 <limits>
+
+#include "Framework/runDataProcessing.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/AnalysisDataModel.h"
+
+using namespace o2;
+using namespace o2::framework;
+
+struct trackQAConverter {
+  Produces<aod::TracksQA_001> tracksQA_001;
+
+  void process(aod::TracksQA_000 const& tracksQA_000)
+  {
+    for (const auto& trackQA : tracksQA_000) {
+      tracksQA_001(
+        trackQA.trackId(),
+        trackQA.tpcTime0(),
+        trackQA.tpcdcaR(),
+        trackQA.tpcdcaZ(),
+        trackQA.tpcClusterByteMask(),
+        trackQA.tpcdEdxMax0R(),
+        trackQA.tpcdEdxMax1R(),
+        trackQA.tpcdEdxMax2R(),
+        trackQA.tpcdEdxMax3R(),
+        trackQA.tpcdEdxTot0R(),
+        trackQA.tpcdEdxTot1R(),
+        trackQA.tpcdEdxTot2R(),
+        trackQA.tpcdEdxTot3R(),
+        // dummy values, not available in _000
+        std::numeric_limits<int8_t>::min(),  // deltaRefContParamY
+        std::numeric_limits<int8_t>::min(),  // deltaRefContParamZ
+        std::numeric_limits<int8_t>::min(),  // deltaRefContParamSnp
+        std::numeric_limits<int8_t>::min(),  // deltaRefContParamTgl
+        std::numeric_limits<int8_t>::min(),  // deltaRefContParamQ2Pt
+        std::numeric_limits<int8_t>::min(),  // deltaRefGloParamY
+        std::numeric_limits<int8_t>::min(),  // deltaRefGloParamZ
+        std::numeric_limits<int8_t>::min(),  // deltaRefGloParamSnp
+        std::numeric_limits<int8_t>::min(),  // deltaRefGloParamTgl
+        std::numeric_limits<int8_t>::min()); // deltaRefGloParamQ2Pt
+    }
+  }
+};
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  return WorkflowSpec{
+    adaptAnalysisTask<trackQAConverter>(cfgc),
+  };
+}

Common/TableProducer/PID/pidTOFMerge.cxx

@@ -206,7 +206,7 @@ struct TOFCalibConfig {
     const std::string nameShiftPos = metadataInfo.isMC() ? mTimeShiftCCDBPathPosMC : mTimeShiftCCDBPathPos;
     updateTimeShift(nameShiftPos, true);
     const std::string nameShiftNeg = metadataInfo.isMC() ? mTimeShiftCCDBPathNegMC : mTimeShiftCCDBPathNeg;
-    updateTimeShift(nameShiftNeg, true);
+    updateTimeShift(nameShiftNeg, false);
 
     // Calibration object is defined
     LOG(info) << "Parametrization at init time:";
@@ -690,7 +690,7 @@ struct tofEventTime {
           if constexpr (removeTOFEvTimeBias) {
             evTimeMakerTOF.removeBias<Run3TrksWtof::iterator, filterForTOFEventTime>(trk, nGoodTracksForTOF, t0TOF[0], t0TOF[1], 2);
           }
-          if (t0TOF[1] < errDiamond && (maxEvTimeTOF <= 0 || abs(t0TOF[0]) < maxEvTimeTOF)) {
+          if (t0TOF[1] < errDiamond && (maxEvTimeTOF <= 0 || std::abs(t0TOF[0]) < maxEvTimeTOF)) {
             flags |= o2::aod::pidflags::enums::PIDFlags::EvTimeTOF;
 
             weight = 1.f / (t0TOF[1] * t0TOF[1]);
@@ -754,7 +754,7 @@ struct tofEventTime {
             evTimeMakerTOF.removeBias<Run3TrksWtof::iterator, filterForTOFEventTime>(trk, nGoodTracksForTOF, et, erret, 2);
           }
           uint8_t flags = 0;
-          if (erret < errDiamond && (maxEvTimeTOF <= 0.f || abs(et) < maxEvTimeTOF)) {
+          if (erret < errDiamond && (maxEvTimeTOF <= 0.f || std::abs(et) < maxEvTimeTOF)) {
             flags |= o2::aod::pidflags::enums::PIDFlags::EvTimeTOF;
           } else {
             et = 0.f;

Common/TableProducer/multiplicityExtraTable.cxx

@@ -245,6 +245,7 @@ struct MultiplicityExtraTable {
         tru(multFDDA), tru(multFDDC), tru(multZNA), tru(multZNC), tru(multZEM1),
         tru(multZEM2), tru(multZPA), tru(multZPC), Tvx, isFV0OrA,
         multFV0TriggerBits, multFT0TriggerBits, multFDDTriggerBits, multBCTriggerMask, collidingBC,
+        bc.timestamp(),
         bc.flags());
     }
   }

Common/TableProducer/multiplicityTable.cxx

@@ -9,10 +9,10 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include <vector>;
-#include <algorithm>;
-#include <map>;
-#include <string>;
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <string>
 
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/runDataProcessing.h"