Merge branch 'AliceO2Group:master' into master

Author: Shunsuke-Kurita

Common/Tasks/qVectorsCorrection.cxx

@@ -202,10 +202,8 @@ struct qVectorsCorrection {
   {
     histosQA.fill(HIST("histCentFull"), qVec.cent());
     if (cfgAddEvtSel && (!qVec.sel8() ||
-                         !qVec.selection_bit(aod::evsel::kNoTimeFrameBorder) ||
-                         !qVec.selection_bit(aod::evsel::kNoTimeFrameBorder) ||
-                         !qVec.selection_bit(aod::evsel::kNoITSROFrameBorder) ||
-                         !qVec.selection_bit(aod::evsel::kNoITSROFrameBorder))) {
+                         !qVec.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV) ||
+                         !qVec.selection_bit(aod::evsel::kNoSameBunchPileup))) {
       return;
     }
     fillHistosQvec(qVec);

DPG/Tasks/AOTTrack/PID/qaPIDTOFEvTime.cxx

@@ -195,13 +195,19 @@ struct tofPidCollisionTimeQa {
     makeEfficiency("effTOFT0ACEvTime", "Efficiency of the TOF+T0AC Event Time");
     makeEfficiency("effT0AEvTime", "Efficiency of the T0A Event Time");
     makeEfficiency("effT0CEvTime", "Efficiency of the T0C Event Time");
+
+    if (!doprocessMC) {
+      return;
+    }
+    histos.add("MC/t", "", HistType::kTH1F, {{1000, -1000, 1000, "MC time"}});
   }
 
-  using Trks = soa::Join<aod::Tracks, aod::TracksExtra, aod::TOFSignal, aod::TOFEvTime, aod::pidEvTimeFlags, aod::pidTOFbeta, aod::pidTOFmass, aod::EvTimeTOFOnly, aod::TrackSelection>;
+  using Trks = soa::Join<aod::Tracks, aod::TracksExtra, aod::TOFSignal, aod::TOFEvTime, aod::EvTimeTOFOnly, aod::pidEvTimeFlags,
+                         aod::pidTOFbeta, aod::pidTOFmass, aod::EvTimeTOFOnly, aod::TrackSelection>;
   using EvTimeCollisions = soa::Join<aod::Collisions, aod::EvSels, aod::FT0sCorrected>;
   // Define slice per collision
   Preslice<Trks> perCollision = aod::track::collisionId;
-  void process(Trks const& tracks, EvTimeCollisions const&)
+  void processData(Trks const& tracks, EvTimeCollisions const&)
   {
     static int ncolls = 0;
     int lastCollisionId = -1; // Last collision ID analysed
@@ -211,7 +217,6 @@ struct tofPidCollisionTimeQa {
       } else if (t.collisionId() == lastCollisionId) { // Event was already processed
         continue;
       }
-      // Create new table for the tracks in a collision
       lastCollisionId = t.collisionId(); /// Cache last collision ID
       auto collision = t.collision_as<EvTimeCollisions>();
 
@@ -402,9 +407,35 @@ struct tofPidCollisionTimeQa {
       static_cast<TEfficiency*>(listEfficiency->FindObject("effTOFT0ACEvTime"))->Fill(t.isEvTimeTOF() && collision.has_foundFT0() && collision.t0ACorrectedValid(), nTracksWithTOF);
     }
   }
+  PROCESS_SWITCH(tofPidCollisionTimeQa, processData, "Process data", true);
+
+  using TrksMC = soa::Join<Trks, aod::McTrackLabels>;
+  using EvTimeCollisionsMC = soa::Join<EvTimeCollisions, aod::McCollisionLabels>;
+  void processMC(TrksMC const& tracks,
+                 EvTimeCollisionsMC const&,
+                 aod::McParticles const&,
+                 aod::BCs const&,
+                 aod::McCollisions const&)
+  {
+    // static int ncolls = 0;
+    int lastCollisionId = -1; // Last collision ID analysed
+
+    for (auto& t : tracks) {
+      if (!t.has_collision()) { // Track was not assigned to a collision
+        continue;
+      } else if (t.collisionId() == lastCollisionId) { // Event was already processed
+        continue;
+      }
+      lastCollisionId = t.collisionId(); /// Cache last collision ID
+      const auto& collision = t.collision_as<EvTimeCollisionsMC>();
+      if (!collision.has_mcCollision()) {
+        continue;
+      }
+      const auto& collisionMC = collision.mcCollision_as<aod::McCollisions>();
+      histos.fill(HIST("MC/t"), collisionMC.t());
+    }
+  }
+  PROCESS_SWITCH(tofPidCollisionTimeQa, processMC, "Process MC", true);
 };
 
-WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
-{
-  return WorkflowSpec{adaptAnalysisTask<tofPidCollisionTimeQa>(cfgc)};
-}
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask<tofPidCollisionTimeQa>(cfgc)}; }

EventFiltering/CMakeLists.txt

@@ -62,6 +62,11 @@ o2physics_add_dpl_workflow(cf-filter-qa
     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
     COMPONENT_NAME Analysis)
 
+o2physics_add_dpl_workflow(cf-filter-ppphi
+    SOURCES PWGCF/CFFilterPPPhi.cxx
+    PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore
+    COMPONENT_NAME Analysis)
+
 o2physics_add_dpl_workflow(je-filter
     SOURCES PWGJE/jetFilter.cxx
     PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::PWGJECore FastJet::FastJet FastJet::Contrib

EventFiltering/PWGCF/CFFilterPPPhi.cxx

@@ -16,7 +16,7 @@ o2physics_add_dpl_workflow(flow-pt-efficiency
 
 o2physics_add_dpl_workflow(flow-pbpb-task
                     SOURCES FlowPbPbTask.cxx
-                    PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::GFWCore
+                    PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore O2Physics::AnalysisCCDB O2Physics::GFWCore
                     COMPONENT_NAME Analysis)
 
 o2physics_add_dpl_workflow(flow-gfw-pbpb

PWGCF/Flow/Tasks/CMakeLists.txt

@@ -27,6 +27,7 @@
 #include "Common/DataModel/TrackSelectionTables.h"
 #include "Common/DataModel/Centrality.h"
 #include "Common/DataModel/Multiplicity.h"
+#include "Common/CCDB/ctpRateFetcher.h"
 
 #include "GFWPowerArray.h"
 #include "GFW.h"
@@ -56,6 +57,8 @@ struct FlowPbPbTask {
   O2_DEFINE_CONFIGURABLE(cfgCutTPCclu, float, 70.0f, "minimum TPC clusters")
   O2_DEFINE_CONFIGURABLE(cfgUseAdditionalEventCut, bool, false, "Use additional event cut on mult correlations")
   O2_DEFINE_CONFIGURABLE(cfgUseAdditionalTrackCut, bool, false, "Use additional track cut on phi")
+  O2_DEFINE_CONFIGURABLE(cfgUseInteractionRateCut, bool, false, "Use events with low interaction rate")
+  O2_DEFINE_CONFIGURABLE(cfgCutIR, float, 50.0, "maximum interaction rate (kHz)")
   O2_DEFINE_CONFIGURABLE(cfgUseNch, bool, false, "Use Nch for flow observables")
   O2_DEFINE_CONFIGURABLE(cfgNbootstrap, int, 10, "Number of subsamples")
   O2_DEFINE_CONFIGURABLE(cfgOutputNUAWeights, bool, false, "Fill and output NUA weights")
@@ -112,6 +115,12 @@ struct FlowPbPbTask {
     // Count the total number of enum
     kCount_ExtraProfile
   };
+  int mRunNumber{-1};
+  uint64_t mSOR{0};
+  double mMinSeconds{-1.};
+  std::unordered_map<int, TH2*> gHadronicRate;
+  ctpRateFetcher mRateFetcher;
+  TH2* gCurrentHadronicRate;
 
   using aodCollisions = soa::Filtered<soa::Join<aod::Collisions, aod::EvSels, aod::CentFT0Cs, aod::Mults>>;
   using aodTracks = soa::Filtered<soa::Join<aod::Tracks, aod::TrackSelection, aod::TracksExtra, aod::TracksDCA>>;
@@ -517,6 +526,23 @@ struct FlowPbPbTask {
     return true;
   }
 
+  void initHadronicRate(aod::BCsWithTimestamps::iterator const& bc)
+  {
+    if (mRunNumber == bc.runNumber()) {
+      return;
+    }
+    mRunNumber = bc.runNumber();
+    if (gHadronicRate.find(mRunNumber) == gHadronicRate.end()) {
+      auto runDuration = ccdb->getRunDuration(mRunNumber);
+      mSOR = runDuration.first;
+      mMinSeconds = std::floor(mSOR * 1.e-3);                /// round tsSOR to the highest integer lower than tsSOR
+      double maxSec = std::ceil(runDuration.second * 1.e-3); /// round tsEOR to the lowest integer higher than tsEOR
+      const AxisSpec axisSeconds{static_cast<int>((maxSec - mMinSeconds) / 20.f), 0, maxSec - mMinSeconds, "Seconds since SOR"};
+      gHadronicRate[mRunNumber] = registry.add<TH2>(Form("HadronicRate/%i", mRunNumber), ";Time since SOR (s);Hadronic rate (kHz)", kTH2D, {axisSeconds, {510, 0., 51.}}).get();
+    }
+    gCurrentHadronicRate = gHadronicRate[mRunNumber];
+  }
+
   void process(aodCollisions::iterator const& collision, aod::BCsWithTimestamps const&, aodTracks const& tracks)
   {
     registry.fill(HIST("hEventCount"), 0.5);
@@ -545,6 +571,12 @@ struct FlowPbPbTask {
     registry.fill(HIST("hCent"), collision.centFT0C());
     fGFW->Clear();
     auto bc = collision.bc_as<aod::BCsWithTimestamps>();
+    initHadronicRate(bc);
+    double hadronicRate = mRateFetcher.fetch(ccdb.service, bc.timestamp(), mRunNumber, "ZNC hadronic") * 1.e-3; //
+    double seconds = bc.timestamp() * 1.e-3 - mMinSeconds;
+    if (cfgUseInteractionRateCut && hadronicRate > cfgCutIR) // cut on hadronic rate
+      return;
+    gCurrentHadronicRate->Fill(seconds, hadronicRate);
     loadCorrections(bc.timestamp());
     registry.fill(HIST("hEventCount"), 4.5);
 

PWGCF/Flow/Tasks/FlowPbPbTask.cxx

@@ -59,7 +59,7 @@ struct FilterCF {
   O2_DEFINE_CONFIGURABLE(cfgCutMCPt, float, 0.5f, "Minimal pT for particles")
   O2_DEFINE_CONFIGURABLE(cfgCutMCEta, float, 0.8f, "Eta range for particles")
   O2_DEFINE_CONFIGURABLE(cfgVerbosity, int, 1, "Verbosity level (0 = major, 1 = per collision)")
-  O2_DEFINE_CONFIGURABLE(cfgTrigger, int, 7, "Trigger choice: (0 = none, 7 = sel7, 8 = sel8)")
+  O2_DEFINE_CONFIGURABLE(cfgTrigger, int, 7, "Trigger choice: (0 = none, 7 = sel7, 8 = sel8, 9 = sel8 + kNoSameBunchPileup + kIsGoodZvtxFT0vsPV, 10 = sel8 before April, 2024, 11 = sel8 for MC)")
   O2_DEFINE_CONFIGURABLE(cfgCollisionFlags, uint16_t, aod::collision::CollisionFlagsRun2::Run2VertexerTracks, "Request collision flags if non-zero (0 = off, 1 = Run2VertexerTracks)")
   O2_DEFINE_CONFIGURABLE(cfgTransientTables, bool, false, "Output transient tables for collision and track IDs")
   O2_DEFINE_CONFIGURABLE(cfgTrackSelection, int, 0, "Type of track selection (0 = Run 2/3 without systematics | 1 = Run 3 with systematics)")
@@ -98,6 +98,12 @@ struct FilterCF {
       return collision.alias_bit(kINT7) && collision.sel7();
     } else if (cfgTrigger == 8) {
       return collision.sel8();
+    } else if (cfgTrigger == 9) { // relevant only for Pb-Pb
+      return collision.sel8() && collision.selection_bit(aod::evsel::kNoSameBunchPileup) && collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV);
+    } else if (cfgTrigger == 10) { // TVX trigger only (sel8 selection before April, 2024)
+      return collision.selection_bit(aod::evsel::kIsTriggerTVX);
+    } else if (cfgTrigger == 11) { // sel8 selection for MC
+      return collision.selection_bit(aod::evsel::kIsTriggerTVX) && collision.selection_bit(aod::evsel::kNoTimeFrameBorder);
     }
     return false;
   }

PWGCF/TableProducer/filterCorrelations.cxx

@@ -72,7 +72,7 @@ struct CorrelationTask {
   O2_DEFINE_CONFIGURABLE(cfgTwoTrackCutMinRadius, float, 0.8f, "Two track cut: radius in m from which two track cuts are applied");
   O2_DEFINE_CONFIGURABLE(cfgLocalEfficiency, int, 0, "0 = OFF and 1 = ON for local efficiency");
   O2_DEFINE_CONFIGURABLE(cfgCentBinsForMC, int, 0, "0 = OFF and 1 = ON for data like multiplicity/centrality bins for MC steps");
-
+  O2_DEFINE_CONFIGURABLE(cfgTrackBitMask, uint8_t, 0, "BitMask for track selection systematics; refer to the enum TrackSelectionCuts in filtering task");
   // Suggested values: Photon: 0.004; K0 and Lambda: 0.005
   Configurable<LabeledArray<float>> cfgPairCut{"cfgPairCut", {cfgPairCutDefaults[0], 5, {"Photon", "K0", "Lambda", "Phi", "Rho"}}, "Pair cuts on various particles"};
 
@@ -107,7 +107,7 @@ struct CorrelationTask {
 
   // Track filters
   Filter trackFilter = (nabs(aod::track::eta) < cfgCutEta) && (aod::track::pt > cfgCutPt) && ((requireGlobalTrackInFilter()) || (aod::track::isGlobalTrackSDD == (uint8_t) true));
-  Filter cfTrackFilter = (nabs(aod::cftrack::eta) < cfgCutEta) && (aod::cftrack::pt > cfgCutPt);
+  Filter cfTrackFilter = (nabs(aod::cftrack::eta) < cfgCutEta) && (aod::cftrack::pt > cfgCutPt) && ((aod::track::trackType & (uint8_t)cfgTrackBitMask) == (uint8_t)cfgTrackBitMask);
 
   // MC filters
   Filter cfMCCollisionFilter = nabs(aod::mccollision::posZ) < cfgCutVertex;

PWGCF/Tasks/correlations.cxx

@@ -76,6 +76,10 @@ void o2::aod::dqmixing::SetUpMixing(MixingHandler* mh, const char* mixingVarible
     std::vector<float> fZLimsHashing = {-10.0f, -7.5f, -5.0f, -2.5f, 0.0f, 2.5f, 5.0f, 7.5f, 10.0f};
     mh->AddMixingVariable(VarManager::kVtxZ, fZLimsHashing.size(), fZLimsHashing);
   }
+  if (!nameStr.compare("Vtx4")) {
+    std::vector<float> fZLimsHashing = {-10.0f, -9.0f, -8.0f, -7.0f, -6.0f, -5.0f, -4.0f, -3.0f, -2.0f, -1.0f, 0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f};
+    mh->AddMixingVariable(VarManager::kVtxZ, fZLimsHashing.size(), fZLimsHashing);
+  }
   if (!nameStr.compare("Psi2A1")) {
     std::vector<float> fPsi2A = {-TMath::Pi() / 2., 0.0f, TMath::Pi() / 2.};
     mh->AddMixingVariable(VarManager::kPsi2A, fPsi2A.size(), fPsi2A);

PWGDQ/Core/MixingLibrary.cxx

@@ -227,6 +227,7 @@ struct TableMakerMC {
     bool enableBarrelHistos = (context.mOptions.get<bool>("processFull") || context.mOptions.get<bool>("processFullWithCov") ||
                                context.mOptions.get<bool>("processBarrelOnly") || context.mOptions.get<bool>("processBarrelOnlyWithDalitzBits") ||
                                context.mOptions.get<bool>("processBarrelOnlyWithCent") || context.mOptions.get<bool>("processBarrelOnlyWithCov") ||
+                               context.mOptions.get<bool>("processBarrelOnlyWithCovWithCentAndMults") ||
                                context.mOptions.get<bool>("processBarrelOnlyWithMults") || context.mOptions.get<bool>("processAmbiguousBarrelOnly"));
     bool enableMuonHistos = (context.mOptions.get<bool>("processFull") || context.mOptions.get<bool>("processFullWithCov") ||
                              context.mOptions.get<bool>("processMuonOnlyWithCent") || context.mOptions.get<bool>("processMuonOnlyWithCov") ||
@@ -434,7 +435,7 @@ struct TableMakerMC {
 
       event(tag, bc.runNumber(), collision.posX(), collision.posY(), collision.posZ(), collision.numContrib(), collision.collisionTime(), collision.collisionTimeRes());
       if constexpr ((TEventFillMap & VarManager::ObjTypes::CollisionMult) > 0 && (TEventFillMap & VarManager::ObjTypes::CollisionCent) > 0) {
-        eventExtended(collision.bc().globalBC(), collision.bc().triggerMask(), 0, triggerAliases, VarManager::fgValues[VarManager::kCentVZERO],
+        eventExtended(bc.globalBC(), bc.triggerMask(), bc.timestamp(), triggerAliases, VarManager::fgValues[VarManager::kCentVZERO],
                       collision.multTPC(), collision.multFV0A(), collision.multFV0C(), collision.multFT0A(), collision.multFT0C(),
                       collision.multFDDA(), collision.multFDDC(), collision.multZNA(), collision.multZNC(), collision.multTracklets(), collision.multNTracksPV(),
                       collision.centFT0C());
@@ -1561,6 +1562,14 @@ struct TableMakerMC {
     fullSkimming<gkEventFillMapWithMults, gkTrackFillMapWithCov, 0u>(collisions, bcs, tracksBarrel, nullptr, mcEvents, mcTracks, nullptr, nullptr);
   }
 
+  // Produce barrel only tables, with centrality, multiplicity and cov matrix -------------------------------------------------------------------
+  void processBarrelOnlyWithCovWithCentAndMults(MyEventsWithCentAndMults const& collisions, aod::BCsWithTimestamps const& bcs,
+                                                soa::Filtered<MyBarrelTracksWithCov> const& tracksBarrel,
+                                                aod::McCollisions const& mcEvents, aod::McParticles_001 const& mcTracks)
+  {
+    fullSkimming<gkEventFillMapWithCentAndMults, gkTrackFillMapWithCov, 0u>(collisions, bcs, tracksBarrel, nullptr, mcEvents, mcTracks, nullptr, nullptr);
+  }
+
   // Produce barrel only tables, with cov matrix and dalitz bits-----------------------------------------------------------------------
   void processBarrelOnlyWithDalitzBits(MyEvents const& collisions, aod::BCsWithTimestamps const& bcs,
                                        soa::Filtered<MyBarrelTracksWithDalitzBits> const& tracksBarrel,
@@ -1658,6 +1667,7 @@ struct TableMakerMC {
   PROCESS_SWITCH(TableMakerMC, processBarrelOnlyWithCent, "Produce barrel skims, w/ centrality", false);
   PROCESS_SWITCH(TableMakerMC, processBarrelOnlyWithCentAndMults, "Produce barrel skims, w/ centrality and mults", false);
   PROCESS_SWITCH(TableMakerMC, processBarrelOnlyWithCov, "Produce barrel skims, with track covariance matrix", false);
+  PROCESS_SWITCH(TableMakerMC, processBarrelOnlyWithCovWithCentAndMults, "Produce barrel skims, w/ centrality and mults, with track covariance matrix", false);
   PROCESS_SWITCH(TableMakerMC, processBarrelOnlyWithDalitzBits, "Produce barrel skims, and dalitz bits", false);
   PROCESS_SWITCH(TableMakerMC, processMuonOnly, "Produce muon skims", false);
   PROCESS_SWITCH(TableMakerMC, processMuonOnlyWithCov, "Produce muon skims, with muon covariance matrix", false);