Merge branch 'AliceO2Group:master' into pmd-qa

Author: abmodak

ALICE3/TableProducer/OTF/onTheFlyTofPid.cxx

@@ -55,6 +55,8 @@
 #include "DetectorsVertexing/HelixHelper.h"
 #include "TableHelper.h"
 #include "ALICE3/Core/DelphesO2TrackSmearer.h"
+#include "TEfficiency.h"
+#include "THashList.h"
 
 using namespace o2;
 using namespace o2::framework;
@@ -117,6 +119,8 @@ struct OnTheFlyTofPid {
     Configurable<int> nBinsTimeRes{"nBinsTimeRes", 400, "number of bins plots time resolution"};
     Configurable<int> nBinsRelativeEtaPt{"nBinsRelativeEtaPt", 400, "number of bins plots pt and eta relative errors"};
     Configurable<int> nBinsEta{"nBinsEta", 400, "number of bins plot relative eta error"};
+    Configurable<int> nBinsMult{"nBinsMult", 200, "number of bins in multiplicity"};
+    Configurable<float> maxMultRange{"maxMultRange", 1000.f, "upper limit in multiplicity plots"};
   } plotsConfig;
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrNONE;
@@ -129,6 +133,7 @@ struct OnTheFlyTofPid {
 
   // for handling basic QA histograms if requested
   HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject};
+  OutputObj<THashList> listEfficiency{"efficiency"};
   static constexpr int kParticles = 5;
 
   void init(o2::framework::InitContext& initContext)
@@ -179,13 +184,16 @@ struct OnTheFlyTofPid {
     }
 
     if (plotsConfig.doQAplots) {
-      const AxisSpec axisdNdeta{200, 0.0f, 1000.0f, Form("dN/d#eta in |#eta| < %f", simConfig.multiplicityEtaRange.value)};
+      const AxisSpec axisdNdeta{plotsConfig.nBinsMult, 0.0f, plotsConfig.maxMultRange, Form("dN/d#eta in |#eta| < %f", simConfig.multiplicityEtaRange.value)};
 
       histos.add("h1dNdeta", "h2dNdeta", kTH1F, {axisdNdeta});
       histos.add("h2dEventTime", "h2dEventTime", kTH2F, {{200, -1000, 1000, "computed"}, {200, -1000, 1000, "generated"}});
       histos.add("h1dEventTimegen", "h1dEventTimegen", kTH1F, {{200, -1000, 1000, "generated"}});
       histos.add("h1dEventTimerec", "h1dEventTimerec", kTH1F, {{200, -1000, 1000, "computed"}});
+      histos.add("h1dEventTimedelta", "h1dEventTimedelta", kTH1F, {{200, -1000, 1000, "generated - computed"}});
       histos.add("h2dEventTimeres", "h2dEventTimeres", kTH2F, {axisdNdeta, {300, 0, 300, "resolution"}});
+      listEfficiency.setObject(new THashList);
+      listEfficiency->Add(new TEfficiency("effEventTime", "effEventTime", plotsConfig.nBinsMult, 0.0f, plotsConfig.maxMultRange));
 
       const AxisSpec axisMomentum{static_cast<int>(plotsConfig.nBinsP), 0.0f, +10.0f, "#it{p} (GeV/#it{c})"};
       const AxisSpec axisMomentumSmall{static_cast<int>(plotsConfig.nBinsP), 0.0f, +1.0f, "#it{p} (GeV/#it{c})"};
@@ -564,8 +572,9 @@ struct OnTheFlyTofPid {
     // Now we compute the event time for the tracks
 
     std::array<float, 2> tzero = {0.f, 0.f};
+    bool etStatus = false;
     if (simConfig.considerEventTime.value) {
-      const bool etStatus = eventTime(tracksWithTime, tzero);
+      etStatus = eventTime(tracksWithTime, tzero);
       if (!etStatus) {
         LOG(warning) << "Event time calculation failed with " << tracksWithTime.size() << " tracks";
       }
@@ -576,6 +585,10 @@ struct OnTheFlyTofPid {
       histos.fill(HIST("h1dEventTimegen"), eventCollisionTimePS);
       histos.fill(HIST("h1dEventTimerec"), tzero[0]);
       histos.fill(HIST("h2dEventTimeres"), dNdEta, tzero[1]);
+      if (etStatus) {
+        histos.fill(HIST("h1dEventTimedelta"), eventCollisionTimePS - tzero[0]);
+      }
+      static_cast<TEfficiency*>(listEfficiency->At(0))->Fill(etStatus, dNdEta);
     }
 
     // Then we do a second loop to compute the measured quantities with the measured event time

Common/CCDB/CMakeLists.txt

@@ -21,3 +21,6 @@ o2physics_target_root_dictionary(AnalysisCCDB
               HEADERS ctpRateFetcher.h
               HEADERS RCTSelectionFlags.h
               LINKDEF AnalysisCCDBLinkDef.h)
+
+o2physics_add_header_only_library(RCTSelectionFlags
+                                  HEADERS RCTSelectionFlags.h)

Common/Core/TableHelper.h

@@ -20,6 +20,7 @@
 
 #include <string>
 
+#include "Framework/Configurable.h"
 #include "Framework/InitContext.h"
 #include "Framework/RunningWorkflowInfo.h"
 
@@ -95,4 +96,15 @@ bool getTaskOptionValue(o2::framework::InitContext& initContext, const std::stri
   return false;
 }
 
+/// Function to check for a specific configurable from another task in the current workflow and fetch its value. Useful for tasks that need to know the value of a configurable in another task.
+/// @param initContext initContext of the init function
+/// @param taskName name of the task to check for
+/// @param value Task configurable to inherit from (name and values are used)
+/// @param verbose if true, print debug messages
+template <typename ValueType>
+bool getTaskOptionValue(o2::framework::InitContext& initContext, const std::string& taskName, ValueType& configurable, const bool verbose = true)
+{
+  return getTaskOptionValue(initContext, taskName, configurable.name, configurable.value, verbose);
+}
+
 #endif // COMMON_CORE_TABLEHELPER_H_

Common/DataModel/PIDResponseTOF.h

@@ -27,6 +27,7 @@
 #include "Framework/AnalysisDataModel.h"
 #include "ReconstructionDataFormats/PID.h"
 #include "Framework/Logger.h"
+#include "Common/Core/PID/PIDTOF.h"
 
 namespace o2::aod
 {
@@ -209,6 +210,65 @@ perSpeciesWrapper(tofExpSignalDiff);
 
 } // namespace pidutils
 
+// Extra tables
+namespace pidflags
+{
+
+namespace enums
+{
+enum PIDFlags : uint8_t {
+  EvTimeUndef = 0x0,  // Event collision not set, corresponding to the LHC Fill event time
+  EvTimeTOF = 0x1,    // Event collision time from TOF
+  EvTimeT0AC = 0x2,   // Event collision time from the FT0AC
+  EvTimeTOFT0AC = 0x4 // Event collision time from the TOF and FT0AC
+};
+}
+
+DECLARE_SOA_COLUMN(GoodTOFMatch, goodTOFMatch, bool);        //! Bool for the TOF PID information on the single track information
+DECLARE_SOA_COLUMN(TOFFlags, tofFlags, uint8_t);             //! Flag for the complementary TOF PID information for the event time
+DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeDefined, isEvTimeDefined, //! True if the Event Time was computed with any method i.e. there is a usable event time
+                           [](uint8_t flags) -> bool { return (flags > 0); });
+DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeTOF, isEvTimeTOF, //! True if the Event Time was computed with the TOF
+                           [](uint8_t flags) -> bool { return (flags & enums::PIDFlags::EvTimeTOF) == enums::PIDFlags::EvTimeTOF; });
+DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeT0AC, isEvTimeT0AC, //! True if the Event Time was computed with the T0AC
+                           [](uint8_t flags) -> bool { return (flags & enums::PIDFlags::EvTimeT0AC) == enums::PIDFlags::EvTimeT0AC; });
+DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeTOFT0AC, isEvTimeTOFT0AC, //! True if the Event Time was computed with the TOF and T0AC
+                           [](uint8_t flags) -> bool { return (flags & enums::PIDFlags::EvTimeTOFT0AC) == enums::PIDFlags::EvTimeTOFT0AC; });
+
+} // namespace pidflags
+
+DECLARE_SOA_TABLE(pidTOFFlags, "AOD", "pidTOFFlags", //! Table of the flags for TOF signal quality on the track level
+                  pidflags::GoodTOFMatch);
+
+DECLARE_SOA_TABLE(pidEvTimeFlags, "AOD", "pidEvTimeFlags", //! Table of the PID flags for the event time tables
+                  pidflags::TOFFlags,
+                  pidflags::IsEvTimeDefined<pidflags::TOFFlags>,
+                  pidflags::IsEvTimeTOF<pidflags::TOFFlags>,
+                  pidflags::IsEvTimeT0AC<pidflags::TOFFlags>,
+                  pidflags::IsEvTimeTOFT0AC<pidflags::TOFFlags>);
+
+namespace pidtofsignal
+{
+DECLARE_SOA_COLUMN(TOFSignal, tofSignal, float);                   //! TOF signal from track time
+DECLARE_SOA_DYNAMIC_COLUMN(EventCollisionTime, eventCollisionTime, //! Event collision time used for the track. Needs the TOF
+                           [](float signal, float tMinusTexp, float texp) -> float { return texp + tMinusTexp - signal; });
+
+} // namespace pidtofsignal
+
+DECLARE_SOA_TABLE(TOFSignal, "AOD", "TOFSignal", //! Table of the TOF signal
+                  pidtofsignal::TOFSignal,
+                  pidtofsignal::EventCollisionTime<pidtofsignal::TOFSignal>);
+
+namespace pidtofevtime
+{
+DECLARE_SOA_COLUMN(TOFEvTime, tofEvTime, float);       //! event time for TOF signal. Can be obtained via a combination of detectors e.g. TOF, FT0A, FT0C
+DECLARE_SOA_COLUMN(TOFEvTimeErr, tofEvTimeErr, float); //! event time error for TOF. Can be obtained via a combination of detectors e.g. TOF, FT0A, FT0C
+} // namespace pidtofevtime
+
+DECLARE_SOA_TABLE(TOFEvTime, "AOD", "TOFEvTime", //! Table of the TOF event time. One entry per track.
+                  pidtofevtime::TOFEvTime,
+                  pidtofevtime::TOFEvTimeErr);
+
 namespace pidtof
 {
 // Expected signals
@@ -397,69 +457,15 @@ DECLARE_SOA_TABLE(pidTOFHe, "AOD", "pidTOFHe", //! Table of the TOF response wit
 DECLARE_SOA_TABLE(pidTOFAl, "AOD", "pidTOFAl", //! Table of the TOF response with binned Nsigma for alpha
                   pidtof_tiny::TOFNSigmaStoreAl, pidtof_tiny::TOFNSigmaAl<pidtof_tiny::TOFNSigmaStoreAl>);
 
-// Extra tables
-namespace pidflags
-{
-
-namespace enums
-{
-enum PIDFlags : uint8_t {
-  EvTimeUndef = 0x0,  // Event collision not set, corresponding to the LHC Fill event time
-  EvTimeTOF = 0x1,    // Event collision time from TOF
-  EvTimeT0AC = 0x2,   // Event collision time from the FT0AC
-  EvTimeTOFT0AC = 0x4 // Event collision time from the TOF and FT0AC
-};
-}
-
-DECLARE_SOA_COLUMN(GoodTOFMatch, goodTOFMatch, bool);        //! Bool for the TOF PID information on the single track information
-DECLARE_SOA_COLUMN(TOFFlags, tofFlags, uint8_t);             //! Flag for the complementary TOF PID information for the event time
-DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeDefined, isEvTimeDefined, //! True if the Event Time was computed with any method i.e. there is a usable event time
-                           [](uint8_t flags) -> bool { return (flags > 0); });
-DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeTOF, isEvTimeTOF, //! True if the Event Time was computed with the TOF
-                           [](uint8_t flags) -> bool { return (flags & enums::PIDFlags::EvTimeTOF) == enums::PIDFlags::EvTimeTOF; });
-DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeT0AC, isEvTimeT0AC, //! True if the Event Time was computed with the T0AC
-                           [](uint8_t flags) -> bool { return (flags & enums::PIDFlags::EvTimeT0AC) == enums::PIDFlags::EvTimeT0AC; });
-DECLARE_SOA_DYNAMIC_COLUMN(IsEvTimeTOFT0AC, isEvTimeTOFT0AC, //! True if the Event Time was computed with the TOF and T0AC
-                           [](uint8_t flags) -> bool { return (flags & enums::PIDFlags::EvTimeTOFT0AC) == enums::PIDFlags::EvTimeTOFT0AC; });
-
-} // namespace pidflags
-
-DECLARE_SOA_TABLE(pidTOFFlags, "AOD", "pidTOFFlags", //! Table of the flags for TOF signal quality on the track level
-                  pidflags::GoodTOFMatch);
-
-DECLARE_SOA_TABLE(pidEvTimeFlags, "AOD", "pidEvTimeFlags", //! Table of the PID flags for the event time tables
-                  pidflags::TOFFlags,
-                  pidflags::IsEvTimeDefined<pidflags::TOFFlags>,
-                  pidflags::IsEvTimeTOF<pidflags::TOFFlags>,
-                  pidflags::IsEvTimeT0AC<pidflags::TOFFlags>,
-                  pidflags::IsEvTimeTOFT0AC<pidflags::TOFFlags>);
-
-namespace pidtofsignal
-{
-DECLARE_SOA_COLUMN(TOFSignal, tofSignal, float);                   //! TOF signal from track time
-DECLARE_SOA_DYNAMIC_COLUMN(EventCollisionTime, eventCollisionTime, //! Event collision time used for the track. Needs the TOF
-                           [](float signal, float tMinusTexp, float texp) -> float { return texp + tMinusTexp - signal; });
-
-} // namespace pidtofsignal
-
-DECLARE_SOA_TABLE(TOFSignal, "AOD", "TOFSignal", //! Table of the TOF signal
-                  pidtofsignal::TOFSignal,
-                  pidtofsignal::EventCollisionTime<pidtofsignal::TOFSignal>);
-
-namespace pidtofevtime
-{
-DECLARE_SOA_COLUMN(TOFEvTime, tofEvTime, float);       //! event time for TOF signal. Can be obtained via a combination of detectors e.g. TOF, FT0A, FT0C
-DECLARE_SOA_COLUMN(TOFEvTimeErr, tofEvTimeErr, float); //! event time error for TOF. Can be obtained via a combination of detectors e.g. TOF, FT0A, FT0C
-} // namespace pidtofevtime
-
-DECLARE_SOA_TABLE(TOFEvTime, "AOD", "TOFEvTime", //! Table of the TOF event time. One entry per track.
-                  pidtofevtime::TOFEvTime,
-                  pidtofevtime::TOFEvTimeErr);
-
 namespace pidtofbeta
 {
 DECLARE_SOA_COLUMN(Beta, beta, float);           //! TOF beta
 DECLARE_SOA_COLUMN(BetaError, betaerror, float); //! Uncertainty on the TOF beta
+// Dynamic column, i.e. the future
+DECLARE_SOA_DYNAMIC_COLUMN(TOFBetaImp, tofBeta, //! TOF Beta value
+                           [](const float length, const float tofSignal, const float collisionTime) -> float {
+                             return o2::pid::tof::Beta::GetBeta(length, tofSignal, collisionTime);
+                           });
 //
 DECLARE_SOA_COLUMN(ExpBetaEl, expbetael, float);           //! Expected beta of electron
 DECLARE_SOA_COLUMN(ExpBetaElError, expbetaelerror, float); //! Expected uncertainty on the beta of electron
@@ -469,14 +475,24 @@ DECLARE_SOA_DYNAMIC_COLUMN(DiffBetaEl, diffbetael,             //! Difference be
                            [](float beta, float expbetael) -> float { return beta - expbetael; });
 } // namespace pidtofbeta
 
+using TOFBeta = pidtofbeta::TOFBetaImp<o2::aod::track::Length, o2::aod::pidtofsignal::TOFSignal, o2::aod::pidtofevtime::TOFEvTime>;
+
 DECLARE_SOA_TABLE(pidTOFbeta, "AOD", "pidTOFbeta", //! Table of the TOF beta
                   pidtofbeta::Beta, pidtofbeta::BetaError);
 
 namespace pidtofmass
 {
 DECLARE_SOA_COLUMN(TOFMass, mass, float); //! TOF mass
+// Dynamic column, i.e. the future
+DECLARE_SOA_DYNAMIC_COLUMN(TOFMassImp, tofMass, //! TOF Mass value
+                           [](const float length, const float tofSignal, const float collisionTime, const float momentum) -> float {
+                             const float beta = o2::pid::tof::Beta::GetBeta(length, tofSignal, collisionTime);
+                             return o2::pid::tof::TOFMass::GetTOFMass(momentum, beta);
+                           });
 } // namespace pidtofmass
 
+using TOFMass = pidtofmass::TOFMassImp<o2::aod::track::Length, o2::aod::pidtofsignal::TOFSignal, o2::aod::pidtofevtime::TOFEvTime, o2::aod::track::TOFExpMom>;
+
 DECLARE_SOA_TABLE(pidTOFmass, "AOD", "pidTOFmass", //! Table of the TOF mass
                   pidtofmass::TOFMass);
 

DPG/Tasks/AOTTrack/PID/TOF/CMakeLists.txt

@@ -20,6 +20,11 @@ o2physics_add_dpl_workflow(pid-tof-qa-beta
     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
     COMPONENT_NAME Analysis)
 
+o2physics_add_dpl_workflow(pid-tof-qa-beta-imp
+    SOURCES qaPIDTOFBetaImp.cxx
+    PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
+    COMPONENT_NAME Analysis)
+
 o2physics_add_dpl_workflow(pid-tof-qa-mc
     SOURCES qaPIDTOFMC.cxx
     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore