Merge branch 'master' into lambda-r2-update

Author: yashpatley

Common/Core/CollisionAssociation.h

@@ -46,6 +46,12 @@ enum TrackSelection {
   QualityTracksITS = 2
 };
 
+enum PVContrReassocOpt {
+  Disabled = 0,
+  OnlySameBc = 1,
+  SameBcAndLowMult = 2
+};
+
 } // namespace track_association
 } // namespace o2::aod
 
@@ -59,10 +65,11 @@ class CollisionAssociation
   void setNumSigmaForTimeCompat(float nSigma) { mNumSigmaForTimeCompat = nSigma; }
   void setTimeMargin(float timeMargin) { mTimeMargin = timeMargin; }
   void setTrackSelectionOptionForStdAssoc(int option) { mTrackSelection = option; }
-  void setUsePvAssociation(bool enable = true) { mUsePvAssociation = enable; }
+  void setUsePvAssociation(int option = o2::aod::track_association::PVContrReassocOpt::OnlySameBc) { mUsePvAssociation = option; }
   void setIncludeUnassigned(bool enable = true) { mIncludeUnassigned = enable; }
   void setFillTableOfCollIdsPerTrack(bool fill = true) { mFillTableOfCollIdsPerTrack = fill; }
   void setBcWindow(int bcWindow = 115) { mBcWindowForOneSigma = bcWindow; }
+  void setMaxPvContributorsForLowMultReassoc(int pvContributorsMax) { mMaxPvContributorsForLowMultReassoc = pvContributorsMax; }
 
   template <typename TTracks, typename Slice, typename Assoc, typename RevIndices>
   void runStandardAssoc(o2::aod::Collisions const& collisions,
@@ -234,7 +241,7 @@ class CollisionAssociation
           float trackTime = 0;
           float trackTimeRes = 0;
           if constexpr (isCentralBarrel) {
-            if (mUsePvAssociation && trackInWindow.isPVContributor()) {
+            if ((mUsePvAssociation == o2::aod::track_association::PVContrReassocOpt::OnlySameBc && trackInWindow.isPVContributor()) || (mUsePvAssociation == o2::aod::track_association::PVContrReassocOpt::SameBcAndLowMult && trackInWindow.isPVContributor() && trackInWindow.collision().numContrib() > mMaxPvContributorsForLowMultReassoc)) {
               trackTime = trackInWindow.collision().collisionTime(); // if PV contributor, we assume the time to be the one of the collision
               trackTimeRes = o2::constants::lhc::LHCBunchSpacingNS;  // 1 BC
             } else {
@@ -252,7 +259,7 @@ class CollisionAssociation
 
           float thresholdTime = 0.;
           if constexpr (isCentralBarrel) {
-            if (mUsePvAssociation && trackInWindow.isPVContributor()) {
+            if ((mUsePvAssociation == o2::aod::track_association::PVContrReassocOpt::OnlySameBc && trackInWindow.isPVContributor()) || (mUsePvAssociation == o2::aod::track_association::PVContrReassocOpt::SameBcAndLowMult && trackInWindow.isPVContributor() && trackInWindow.collision().numContrib() > mMaxPvContributorsForLowMultReassoc)) {
               thresholdTime = trackTimeRes;
             } else if (TESTBIT(trackInWindow.flags(), o2::aod::track::TrackTimeResIsRange)) {
               // the track time resolution is a range, not a gaussian resolution
@@ -306,7 +313,8 @@ class CollisionAssociation
   float mNumSigmaForTimeCompat{4.};                                                  // number of sigma for time compatibility
   float mTimeMargin{500.};                                                           // additional time margin in ns
   int mTrackSelection{o2::aod::track_association::TrackSelection::GlobalTrackWoDCA}; // track selection for central barrel tracks (standard association only)
-  bool mUsePvAssociation{true};                                                      // use the information of PV contributors
+  int mUsePvAssociation{1};                                                          // use the information of PV contributors (0: off, 1: reassociate only with collisions in the same BC, 2: reassociate with collisions in the same BC, or within time resolution in case of low mult PVs)
+  int mMaxPvContributorsForLowMultReassoc{10};                                       // maximum value of PV contributors to reassociate tracks that are PV contributors to other vertices
   bool mIncludeUnassigned{true};                                                     // include tracks that were originally not assigned to any collision
   bool mFillTableOfCollIdsPerTrack{false};                                           // fill additional table with vectors of compatible collisions per track
   int mBcWindowForOneSigma{115};                                                     // BC window to be multiplied by the number of sigmas to define maximum window to be considered

Common/TableProducer/fwdtrackToCollisionAssociator.cxx

@@ -63,7 +63,7 @@ struct FwdTrackToCollisionAssociation {
     collisionAssociator.setNumSigmaForTimeCompat(nSigmaForTimeCompat);
     collisionAssociator.setTimeMargin(timeMargin);
     collisionAssociator.setTrackSelectionOptionForStdAssoc(track_association::TrackSelection::None);
-    collisionAssociator.setUsePvAssociation(false);
+    collisionAssociator.setUsePvAssociation(track_association::PVContrReassocOpt::Disabled);
     collisionAssociator.setIncludeUnassigned(includeUnassigned);
     collisionAssociator.setFillTableOfCollIdsPerTrack(fillTableOfCollIdsPerTrack);
     collisionAssociator.setBcWindow(bcWindowForOneSigma);

Common/TableProducer/trackToCollisionAssociator.cxx

@@ -39,10 +39,11 @@ struct TrackToCollisionAssociation {
   Configurable<float> nSigmaForTimeCompat{"nSigmaForTimeCompat", 4.f, "number of sigmas for time compatibility"};
   Configurable<float> timeMargin{"timeMargin", 0.f, "time margin in ns added to uncertainty because of uncalibrated TPC"};
   Configurable<int> setTrackSelections{"setTrackSelections", 1, "flag to apply track selections: -1=minimal track selection for Run 2 (standard association); 0=none; 1=global track w/o DCA selection; 2=only ITS quality"};
-  Configurable<bool> usePVAssociation{"usePVAssociation", true, "if the track is a PV contributor, use the collision time for it"};
+  Configurable<int> usePVAssociation{"usePVAssociation", 1, "use information of PV contribution in reassociation; 0 -> off, 1 -> reassociate only with collisions in the same BC, 2 -> as 1 only for tracks associated to high multiplicity vertices"};
   Configurable<bool> includeUnassigned{"includeUnassigned", false, "consider also tracks which are not assigned to any collision"};
   Configurable<bool> fillTableOfCollIdsPerTrack{"fillTableOfCollIdsPerTrack", false, "fill additional table with vector of collision ids per track"};
   Configurable<int> bcWindowForOneSigma{"bcWindowForOneSigma", 60, "BC window to be multiplied by the number of sigmas to define maximum window to be considered"};
+  Configurable<int> maxPvContributorsForLowMultReassoc{"maxPvContributorsForLowMultReassoc", 10, "Maximum number of PV contributors to consider a collision at low multiplicity and reassociate tracks even if PV contributors if enabled"};
 
   CollisionAssociation<true> collisionAssociator;
 
@@ -67,6 +68,7 @@ struct TrackToCollisionAssociation {
     collisionAssociator.setIncludeUnassigned(includeUnassigned);
     collisionAssociator.setFillTableOfCollIdsPerTrack(fillTableOfCollIdsPerTrack);
     collisionAssociator.setBcWindow(bcWindowForOneSigma);
+    collisionAssociator.setMaxPvContributorsForLowMultReassoc(maxPvContributorsForLowMultReassoc);
   }
 
   void processAssocWithTime(Collisions const& collisions, TracksWithSel const& tracksUnfiltered, TracksWithSelFilter const& tracks, AmbiguousTracks const& ambiguousTracks, BCs const& bcs)

EventFiltering/PWGHF/HFFilter.cxx

@@ -492,6 +492,7 @@ struct HfFilter { // Main struct for HF triggers
       bool isSelectedPvZ = (std::fabs(collision.posZ()) < evSel.maxPvZ);
       if (!isSelectedTVX || !isSelectedTFBorder || !isSelectedITSROFBorder || !isSelectedPvZ) {
         tags(keepEvent[kHighPt2P], keepEvent[kHighPt3P], keepEvent[kBeauty3P], keepEvent[kBeauty4P], keepEvent[kFemto2P], keepEvent[kFemto3P], keepEvent[kDoubleCharm2P], keepEvent[kDoubleCharm3P], keepEvent[kDoubleCharmMix], keepEvent[kV0Charm2P], keepEvent[kV0Charm3P], keepEvent[kCharmBarToXiBach], keepEvent[kSigmaCPPK], keepEvent[kSigmaC0K0], keepEvent[kPhotonCharm2P], keepEvent[kPhotonCharm3P], keepEvent[kSingleCharm2P], keepEvent[kSingleCharm3P], keepEvent[kSingleNonPromptCharm2P], keepEvent[kSingleNonPromptCharm3P], keepEvent[kCharmBarToXi2Bach], keepEvent[kPrCharm2P], keepEvent[kBtoJPsiKa], keepEvent[kBtoJPsiKstar], keepEvent[kBtoJPsiPhi], keepEvent[kBtoJPsiPrKa], keepEvent[kBtoJPsiPi], keepEvent[kSigmaCPr]);
+        hProcessedEvents->Fill(1); // rejected
         continue;
       }
 

EventFiltering/macros/uploadOTSobjects.C

@@ -75,8 +75,11 @@ void uploadOTSobjects(std::string inputList, std::string passName, bool useAlien
     if (!hCounterTVX) {
       hCounterTVX = static_cast<TH1*>(scalersFile->Get("lumi-task/hCounterTVX"));
       if (!hCounterTVX) {
-        std::cout << "No hCounterTVX histogram found in the file, skipping upload for run " << runString << std::endl;
-        continue;
+        hCounterTVX = static_cast<TH1*>(scalersFile->Get("eventselection-run3/luminosity/hCounterTVX"));
+        if (!hCounterTVX) {
+          std::cout << "No hCounterTVX histogram found in the file, skipping upload for run " << runString << std::endl;
+          continue;
+        }
       }
     }
     api.storeAsTFile(hCounterTVX, baseCCDBpath + "InspectedTVX", metadata, duration.first, duration.second + 1);

PWGCF/EbyEFluctuations/Tasks/netprotcumulants.cxx

@@ -53,6 +53,41 @@ using namespace o2;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 
+namespace o2::aod
+{
+
+// ===== Event columns =====
+DECLARE_SOA_COLUMN(EventId, eventId, int);
+DECLARE_SOA_COLUMN(MyCent, myCent, float);
+DECLARE_SOA_COLUMN(Vz, vz, float);
+DECLARE_SOA_COLUMN(Ntrk, ntrk, int);
+DECLARE_SOA_COLUMN(Np, np, int);
+DECLARE_SOA_COLUMN(Npbar, npbar, int);
+
+// ===== Track columns =====
+DECLARE_SOA_COLUMN(Pt, pt, float);
+DECLARE_SOA_COLUMN(Eta, eta, float);
+DECLARE_SOA_COLUMN(Pid, pid, int);
+DECLARE_SOA_COLUMN(Eff, eff, float);
+
+// ===== Tables =====
+DECLARE_SOA_TABLE(EventTable, "AOD", "MYEVENT",
+                  EventId,
+                  MyCent,
+                  Vz,
+                  Ntrk,
+                  Np,
+                  Npbar);
+
+DECLARE_SOA_TABLE(MYTrackTable, "AOD", "MYTRACK",
+                  EventId,
+                  Pt,
+                  Eta,
+                  Pid,
+                  Eff);
+
+} // namespace o2::aod
+
 struct NetProtCumulants {
   // events
   Configurable<float> cfgCutVertex{"cfgCutVertex", 10.0f, "Accepted z-vertex range"};
@@ -110,6 +145,26 @@ struct NetProtCumulants {
 
   HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject};
 
+  Produces<aod::EventTable> eventTable;
+  Produces<aod::MYTrackTable> trackTable;
+
+  int eventCounter = 0;
+  int eventId = 0;
+
+  // event variables
+  int Ntrk_event = 0;
+  int Np_event = 0;
+  int Npbar_event = 0;
+
+  float cent_event = 0;
+  float vz_event = 0;
+
+  // track variables
+  float pt_track = 0;
+  float eta_track = 0;
+  int pid_track = 0;
+  float eff_track = 0;
+
   TRandom3* fRndm = new TRandom3(0);
 
   // Eff histograms 2d: eff(pT, eta)
@@ -855,6 +910,7 @@ struct NetProtCumulants {
     if (cfgUsePtDepDCAz) {
       fPtDepDCAz = new TF1("ptDepDCAz", cfgDCAzFunc->c_str(), 0.001, 10.0);
     }
+
   } // end init()
 
   template <typename T>
@@ -2134,6 +2190,18 @@ struct NetProtCumulants {
 
   void processDataRec(AodCollisions::iterator const& coll, aod::BCsWithTimestamps const&, AodTracks const& inputTracks)
   {
+
+    // reset per event
+    Ntrk_event = 0;
+    Np_event = 0;
+    Npbar_event = 0;
+
+    // assign event ID
+    eventId = eventCounter++;
+
+    // store event info
+    cent_event = coll.centFT0C();
+    vz_event = coll.posZ();
     if (!coll.sel8()) {
       return;
     }
@@ -2263,6 +2331,7 @@ struct NetProtCumulants {
       if (cfgIfMandatoryTOF && !track.hasTOF()) {
         continue;
       }
+      Ntrk_event++;
 
       bool trackSelected = false;
       if (cfgPIDchoice == 0)
@@ -2293,11 +2362,18 @@ struct NetProtCumulants {
 
           if (track.pt() < cfgCutPtUpper) {
             nProt = nProt + 1.0;
+            Np_event++;
             float pEff = getEfficiency(track); // get efficiency of track
             if (pEff != 0) {
               for (int i = 1; i < 7; i++) {
                 powerEffProt[i] += std::pow(1.0 / pEff, i);
               }
+              pt_track = track.pt();
+              eta_track = track.eta();
+              pid_track = +1;
+              eff_track = pEff;
+
+              trackTable(eventId, pt_track, eta_track, pid_track, eff_track);
             }
           }
         }
@@ -2311,18 +2387,27 @@ struct NetProtCumulants {
           histos.fill(HIST("hrecDcaZAntiproton"), track.dcaZ());
           if (track.pt() < cfgCutPtUpper) {
             nAntiprot = nAntiprot + 1.0;
+            Npbar_event++;
             float pEff = getEfficiency(track); // get efficiency of track
             if (pEff != 0) {
               for (int i = 1; i < 7; i++) {
                 powerEffAntiprot[i] += std::pow(1.0 / pEff, i);
               }
+              pt_track = track.pt();
+              eta_track = track.eta();
+              pid_track = -1;
+              eff_track = pEff;
+
+              trackTable(eventId, pt_track, eta_track, pid_track, eff_track);
             }
           }
         }
 
       } //! checking PID
     } //! end track loop
 
+    eventTable(eventId, cent_event, vz_event, Ntrk_event, Np_event, Npbar_event);
+
     float netProt = nProt - nAntiprot;
     float nTracks = nProt + nAntiprot;
     histos.fill(HIST("hNTracksVsCent"), cent, nTracks);

PWGCF/Femto/Core/pairHistManager.h

@@ -100,7 +100,8 @@ enum PairHist {
 
   // mixing qa
   kSeNpart1VsNpart2,                         // number of unique particles 1 vs unique number of particles 2 in each same event
-  kMeMixingWindow,                           // mixing window size
+  kMeMixingWindowRaw,                        // mixing window size
+  kMeMixingWindowEffective,                  // mixing window size, counting event pairs with particle pairs
   kMeNpart1VsNpart2,                         // number of unique particles 1 vs number of unique particles 2 in each mixed event
   kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, // correlation of event properties in each mixing bin
 
@@ -233,7 +234,8 @@ constexpr std::array<histmanager::HistInfo<PairHist>, kPairHistogramLast>
       {kTrueMultVsMult, o2::framework::HistType::kTH2F, "hTrueMultVsMult", "Multiplicity_{True} vs Multiplicity; Multiplicity_{True} ;  Multiplicity"},
       {kTrueCentVsCent, o2::framework::HistType::kTH2F, "hTrueCentVsCent", "Centrality_{True} vs Centrality; Centrality_{True} (%); Centrality (%)"},
       {kSeNpart1VsNpart2, o2::framework::HistType::kTH2F, "hSeNpart1VsNpart2", "# unique particle 1 vs # unique particle 2 in each same event; # partilce 1; # particle 2"},
-      {kMeMixingWindow, o2::framework::HistType::kTH1F, "hMeMixingWindow", "Mixing Window; Mixing Windown ; Entries"},
+      {kMeMixingWindowRaw, o2::framework::HistType::kTH1F, "hMeMixingWindowRaw", "Raw Mixing Window; Raw Mixing Window ; Entries"},
+      {kMeMixingWindowEffective, o2::framework::HistType::kTH1F, "hMeMixingWindowEffective", "Effective Mixing Window; Effective Mixing Windown ; Entries"},
       {kMeNpart1VsNpart2, o2::framework::HistType::kTH2F, "hMeNpart1VsNpart2", "# unique particle 1 vs # unique partilce 2 in each mixing bin; # partilce 1; # particle 2"},
       {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, o2::framework::HistType::kTHnSparseF, "hVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2", "Mixing bins; V_{z,1} (cm); multiplicity_{1}; centrality_{1} (%); V_{z,2} (cm); multiplicity_{2}; centrality_{2} (%)"},
     }};
@@ -276,7 +278,8 @@ constexpr std::array<histmanager::HistInfo<PairHist>, kPairHistogramLast>
     {kKstarVsMtVsMinvVsPt1VsPt2VsMultVsCent, {confAnalysis.kstar, confAnalysis.mt, confAnalysis.massInv, confAnalysis.pt1, confAnalysis.pt2, confAnalysis.multiplicity, confAnalysis.centrality}},                           \
     {kDalitz, {confAnalysis.kstar, confAnalysis.dalitzMtot, confAnalysis.dalitzM12, confAnalysis.dalitzM13}},                                                                                                                \
     {kSeNpart1VsNpart2, {confMixing.particleBinning, confMixing.particleBinning}},                                                                                                                                           \
-    {kMeMixingWindow, {confMixing.particleBinning}},                                                                                                                                                                         \
+    {kMeMixingWindowRaw, {confMixing.particleBinning}},                                                                                                                                                                      \
+    {kMeMixingWindowEffective, {confMixing.particleBinning}},                                                                                                                                                                \
     {kMeNpart1VsNpart2, {confMixing.particleBinning, confMixing.particleBinning}},                                                                                                                                           \
     {kMeVtz1VsMult1VsCent1VsVtz2VsMult2VsCent2, {confMixing.vtxBins, confMixing.multBins, confMixing.centBins, confMixing.vtxBins, confMixing.multBins, confMixing.centBins}},
 
@@ -599,7 +602,9 @@ class PairHistManager
   void resetTrackedParticlesPerEvent()
   {
     mParticles1PerEvent.clear();
+    mParticles1PerEvent.reserve(100);
     mParticles2PerEvent.clear();
+    mParticles2PerEvent.reserve(100);
   }
 
   void fillMixingQaSe()
@@ -616,10 +621,11 @@ class PairHistManager
     }
   }
 
-  void fillMixingQaMePerMixingBin(int windowSize)
+  void fillMixingQaMePerMixingBin(int windowSizeRaw, int windowSizeEffective)
   {
-    if (mEventMixingQa) {
-      mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeMixingWindow, HistTable)), windowSize);
+    if (mPairCorrelationQa) {
+      mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeMixingWindowRaw, HistTable)), windowSizeRaw);
+      mHistogramRegistry->fill(HIST(prefix) + HIST(MixingQaDir) + HIST(getHistName(kMeMixingWindowEffective, HistTable)), windowSizeEffective);
     }
   }
 
@@ -732,7 +738,8 @@ class PairHistManager
   {
     std::string mcDir = std::string(prefix) + std::string(MixingQaDir);
     if (mPairCorrelationQa) {
-      mHistogramRegistry->add(mcDir + getHistNameV2(kMeMixingWindow, HistTable), getHistDesc(kMeMixingWindow, HistTable), getHistType(kMeMixingWindow, HistTable), {Specs.at(kMeMixingWindow)});
+      mHistogramRegistry->add(mcDir + getHistNameV2(kMeMixingWindowRaw, HistTable), getHistDesc(kMeMixingWindowRaw, HistTable), getHistType(kMeMixingWindowRaw, HistTable), {Specs.at(kMeMixingWindowRaw)});
+      mHistogramRegistry->add(mcDir + getHistNameV2(kMeMixingWindowEffective, HistTable), getHistDesc(kMeMixingWindowEffective, HistTable), getHistType(kMeMixingWindowEffective, HistTable), {Specs.at(kMeMixingWindowEffective)});
       mHistogramRegistry->add(mcDir + getHistNameV2(kMeNpart1VsNpart2, HistTable), getHistDesc(kMeNpart1VsNpart2, HistTable), getHistType(kMeNpart1VsNpart2, HistTable), {Specs.at(kMeNpart1VsNpart2)});
     }
     if (mEventMixingQa) {