PWGJE : Bug fixes (#5565)

* PWGJE: Fixing bug in THn limit in planarFlow task

* PWGJE: Remove excplicit time border event selection since its included by default in sel8 now

* adding a sel8Full event seleection option with extra cuts

* removing THns from HFJet trigger

* clang fixes to jetderiveddatautilities

* adding event selection to rho estimation in QA tasks

* fixing Nsubjettiness

---------

Co-authored-by: Nima Zardoshti <nzardosh@alicecerno2.cern.ch>

Author: nzardosh

EventFiltering/PWGJE/jetHFFilter.cxx

@@ -61,18 +61,9 @@ struct JetHFFilterTask {
   Configurable<float> jetLcChR{"jetLcChR", 0.6, "jet resolution parameter for charged Lc jet for low pt trigger"};
 
   Configurable<float> vertexZCut{"vertexZCut", 10.0f, "Accepted z-vertex range"};
-  Configurable<bool> fillTHns{"fillTHns", true, "fill THn histograms"};
-
-  Configurable<std::vector<double>> jetRadiiPlot{"jetRadiiPlot", std::vector<double>{0.2, 0.4, 0.6}, "jet resolution parameters"};
 
   void init(o2::framework::InitContext&)
   {
-    auto jetRadiiPlotBins = (std::vector<double>)jetRadiiPlot;
-    if (jetRadiiPlotBins.size() > 1) {
-      jetRadiiPlotBins.push_back(jetRadiiPlotBins[jetRadiiPlotBins.size() - 1] + (TMath::Abs(jetRadiiPlotBins[jetRadiiPlotBins.size() - 1] - jetRadiiPlotBins[jetRadiiPlotBins.size() - 2])));
-    } else {
-      jetRadiiPlotBins.push_back(jetRadiiPlotBins[jetRadiiPlotBins.size() - 1] + 0.1);
-    }
     registry.add("h_d0jet_pt", "D^{0} - tagged jet pT;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 200.}}});
     registry.add("h_d0jet_pt_lowpt", "D^{0} - tagged jet pT;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 200.}}});
     registry.add("h_d0jet_pt_highpt", "D^{0} - tagged jet pT;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 200.}}});
@@ -81,58 +72,40 @@ struct JetHFFilterTask {
     registry.add("h_lcjet_pt_lowpt", "#Lambda^{+}_{c} - tagged jet pT;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 200.}}});
     registry.add("h_lcjet_pt_highpt", "#Lambda^{+}_{c} - tagged jet pT;#it{p}_{T,jet} (GeV/#it{c});entries", {HistType::kTH1F, {{200, 0., 200.}}});
 
-    // these might end up being too big
-    registry.add("d0Thn", "Thn for D^{0}-tagged jets", {HistType::kTHnC, {{jetRadiiPlotBins, ""}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {200, 0., 200.}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {100, -1.0, 1.0}, {1700, 1.3, 3.0}}});
-    registry.add("d0Thn_witheventcuts", "Thn for D^{0}-tagged jets with event cuts", {HistType::kTHnC, {{jetRadiiPlotBins, ""}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {200, 0., 200.}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {100, -1.0, 1.0}, {1700, 1.3, 3.0}}});
-    registry.add("lcThn", "Thn for #Lambda^{+}_{c}-tagged jets", {HistType::kTHnC, {{jetRadiiPlotBins, ""}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {200, 0., 200.}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {100, -1.0, 1.0}, {1700, 1.3, 3.0}}});
-    registry.add("lcThn_witheventcuts", "Thn for #Lambda^{+}_{c}-tagged jets with event cuts", {HistType::kTHnC, {{jetRadiiPlotBins, ""}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {200, 0., 200.}, {200, 0., 200.}, {100, -1.0, 1.0}, {160, -1.0, 7.}, {100, -1.0, 1.0}, {1700, 1.3, 3.0}}});
-    // radius, JetPt, JetEta, Jet Phi, Jet Ntracks, HF pT, HF Eta, HF Phi, HF Y, HF Mass
+    registry.add("h_collisions", "Collision ;entries", {HistType::kTH1F, {{5, 0.0, 5.0}}});
   }
 
   void processJets(soa::Join<JetCollisions, aod::EvSels>::iterator const& collision, soa::Join<o2::aod::D0ChargedJets, o2::aod::D0ChargedJetConstituents> const& d0Jets, CandidatesD0Data const& d0Candidates, soa::Join<o2::aod::LcChargedJets, o2::aod::LcChargedJetConstituents> const& lcJets, CandidatesLcData const& lcCandidates, JetTracks const& tracks)
   {
+    registry.fill(HIST("h_collisions"), 0.5);
     bool keepEvent[kAllObjects]{false};
     for (auto const& d0Jet : d0Jets) {
-      if (fillTHns) {
-        for (auto const& d0Candidate : d0Jet.hfcandidates_as<CandidatesD0Data>()) {
-          registry.fill(HIST("d0Thn"), d0Jet.r() / 100.0, d0Jet.pt(), d0Jet.eta(), d0Jet.phi(), d0Jet.tracksIds().size() + d0Jet.hfcandidatesIds().size(), d0Candidate.pt(), d0Candidate.eta(), d0Candidate.phi(), d0Candidate.y(), d0Candidate.m());
-          if (collision.posZ() < vertexZCut && collision.sel8() && collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) {
-            registry.fill(HIST("d0Thn_witheventcuts"), d0Jet.r() / 100.0, d0Jet.pt(), d0Jet.eta(), d0Jet.phi(), d0Jet.tracksIds().size() + d0Jet.hfcandidatesIds().size(), d0Candidate.pt(), d0Candidate.eta(), d0Candidate.phi(), d0Candidate.y(), d0Candidate.m());
-          }
-          break;
-        }
-      }
       if (d0Jet.r() == round(jetD0ChR * 100.0f)) {
         registry.fill(HIST("h_d0jet_pt"), d0Jet.pt());
         if (d0Jet.pt() >= jetD0ChLowPtThreshold) {
           keepEvent[kJetD0ChLowPt] = true;
           registry.fill(HIST("h_d0jet_pt_lowpt"), d0Jet.pt());
+          registry.fill(HIST("h_collisions"), 1.5);
         }
         if (d0Jet.pt() >= jetD0ChHighPtThreshold) {
           keepEvent[kJetD0ChHighPt] = true;
           registry.fill(HIST("h_d0jet_pt_highpt"), d0Jet.pt());
+          registry.fill(HIST("h_collisions"), 2.5);
         }
       }
     }
     for (auto const& lcJet : lcJets) {
-      if (fillTHns) {
-        for (auto const& lcCandidate : lcJet.hfcandidates_as<CandidatesLcData>()) {
-          registry.fill(HIST("lcThn"), lcJet.r() / 100.0, lcJet.pt(), lcJet.eta(), lcJet.phi(), lcJet.tracksIds().size() + lcJet.hfcandidatesIds().size(), lcCandidate.pt(), lcCandidate.eta(), lcCandidate.phi(), lcCandidate.y(), lcCandidate.m());
-          if (collision.posZ() < vertexZCut && collision.sel8() && collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) {
-            registry.fill(HIST("lcThn_witheventcuts"), lcJet.r() / 100.0, lcJet.pt(), lcJet.eta(), lcJet.phi(), lcJet.tracksIds().size() + lcJet.hfcandidatesIds().size(), lcCandidate.pt(), lcCandidate.eta(), lcCandidate.phi(), lcCandidate.y(), lcCandidate.m());
-          }
-          break;
-        }
-      }
       if (lcJet.r() == round(jetLcChR * 100.0f)) {
         registry.fill(HIST("h_lcjet_pt"), lcJet.pt());
         if (lcJet.pt() >= jetLcChLowPtThreshold) {
           keepEvent[kJetLcChLowPt] = true;
           registry.fill(HIST("h_lcjet_pt_lowpt"), lcJet.pt());
+          registry.fill(HIST("h_collisions"), 3.5);
         }
         if (lcJet.pt() >= jetLcChHighPtThreshold) {
           keepEvent[kJetLcChHighPt] = true;
           registry.fill(HIST("h_lcjet_pt_highpt"), lcJet.pt());
+          registry.fill(HIST("h_collisions"), 4.5);
         }
       }
     }

PWGJE/Core/JetDerivedDataUtilities.h

@@ -28,10 +28,8 @@ static constexpr float mPion = 0.139; // TDatabasePDG::Instance()->GetParticle(2
 
 enum JCollisionSel {
   sel8 = 0,
-  sel8WithoutTimeFrameBorderCut = 1,
-  sel7 = 2,
-  sel7WithoutTimeFrameBorderCut = 3,
-  WithoutTimeFrameBorderCut = 4
+  sel8Full = 1,
+  sel7 = 2
 };
 
 template <typename T>
@@ -47,40 +45,28 @@ int initialiseEventSelection(std::string eventSelection)
 {
   if (eventSelection == "sel8") {
     return JCollisionSel::sel8;
-  } else if (eventSelection == "sel8WithoutTimeFrameBorderCut") {
-    return JCollisionSel::sel8WithoutTimeFrameBorderCut;
-  } else if (eventSelection == "sel7") {
+  }
+  if (eventSelection == "sel8Full") {
+    return JCollisionSel::sel8Full;
+  }
+  if (eventSelection == "sel7") {
     return JCollisionSel::sel7;
-  } else if (eventSelection == "sel7WithoutTimeFrameBorderCut") {
-    return JCollisionSel::sel7WithoutTimeFrameBorderCut;
-  } else if (eventSelection == "WithoutTimeFrameBorderCut") {
-    return JCollisionSel::WithoutTimeFrameBorderCut;
   }
   return -1;
 }
 
 template <typename T>
-uint16_t setEventSelectionBit(T const& collision)
+uint8_t setEventSelectionBit(T const& collision)
 {
-
-  uint16_t bit = 0;
-
-  if (!collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) {
-    SETBIT(bit, JCollisionSel::WithoutTimeFrameBorderCut);
-  }
+  uint8_t bit = 0;
   if (collision.sel8()) {
-    if (collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) {
-      SETBIT(bit, JCollisionSel::sel8);
-    } else {
-      SETBIT(bit, JCollisionSel::sel8WithoutTimeFrameBorderCut);
+    SETBIT(bit, JCollisionSel::sel8);
+    if (collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup) && collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) {
+      SETBIT(bit, JCollisionSel::sel8Full);
     }
   }
   if (collision.sel7()) {
-    if (collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) {
-      SETBIT(bit, JCollisionSel::sel7);
-    } else {
-      SETBIT(bit, JCollisionSel::sel7WithoutTimeFrameBorderCut);
-    }
+    SETBIT(bit, JCollisionSel::sel7);
   }
   return bit;
 }

PWGJE/Core/JetSubstructureUtilities.h

@@ -110,7 +110,7 @@ std::vector<float> getNSubjettiness(T const& jet, U const& tracks, V const& clus
     result.push_back(-1.0 * (n + 1));
   }
 
-  for (auto n = 1; n < nMax + 1; n++) {
+  for (auto n = 1; n <= nMax; n++) {
     if (pseudoJet.constituents().size() < n) { // Tau_N needs at least N tracks
       return result;
     }

PWGJE/DataModel/JetReducedData.h

@@ -66,7 +66,7 @@ DECLARE_SOA_COLUMN(PosY, posY, float);
 DECLARE_SOA_COLUMN(PosZ, posZ, float);
 DECLARE_SOA_COLUMN(Multiplicity, multiplicity, float);
 DECLARE_SOA_COLUMN(Centrality, centrality, float);
-DECLARE_SOA_COLUMN(EventSel, eventSel, uint16_t);
+DECLARE_SOA_COLUMN(EventSel, eventSel, uint8_t);
 DECLARE_SOA_BITMAP_COLUMN(Alias, alias, 32);
 DECLARE_SOA_COLUMN(ChargedTriggerSel, chargedTriggerSel, uint8_t);
 DECLARE_SOA_COLUMN(FullTriggerSel, fullTriggerSel, uint32_t);

PWGJE/Tasks/jetfinderQA.cxx

@@ -862,6 +862,9 @@ struct JetFinderQATask {
 
   void processRho(soa::Filtered<soa::Join<JetCollisions, aod::BkgChargedRhos>>::iterator const& collision, soa::Filtered<JetTracks> const& tracks)
   {
+    if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) {
+      return;
+    }
     int nTracks = 0;
     for (auto const& track : tracks) {
       if (jetderiveddatautilities::selectTrack(track, trackSelection)) {
@@ -878,7 +881,9 @@ struct JetFinderQATask {
 
   void processRandomCone(soa::Filtered<soa::Join<JetCollisions, aod::BkgChargedRhos>>::iterator const& collision, soa::Join<aod::ChargedJets, aod::ChargedJetConstituents> const& jets, JetTracks const& tracks)
   {
-
+    if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) {
+      return;
+    }
     TRandom3 randomNumber(0);
     float randomConeEta = randomNumber.Uniform(trackEtaMin + randomConeR, trackEtaMax - randomConeR);
     float randomConePhi = randomNumber.Uniform(0.0, 2 * M_PI);

PWGJE/Tasks/jetfinderhfQA.cxx

@@ -1415,6 +1415,9 @@ struct JetFinderHFQATask {
 
   void processRho(JetCollision const& collision, CandidateTableData const& candidates, BkgRhoTable const& bkgRhos, soa::Filtered<JetTracks> const& tracks)
   {
+    if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) {
+      return;
+    }
     for (auto const& candidate : candidates) {
       auto bkgRho = jethfutilities::slicedPerCandidate(bkgRhos, candidate, perD0CandidateRhos, perLcCandidateRhos, perBplusCandidateRhos).iteratorAt(0);
       int nTracks = 0;
@@ -1435,7 +1438,9 @@ struct JetFinderHFQATask {
 
   void processRandomCone(soa::Filtered<JetCollisions>::iterator const& collision, JetTableDataSubJoined const& jets, CandidateTableData const& candidates, BkgRhoTable const& bkgRhos, soa::Filtered<JetTracks> const& tracks)
   {
-
+    if (!jetderiveddatautilities::selectCollision(collision, eventSelection)) {
+      return;
+    }
     for (auto const& candidate : candidates) {
       auto bkgRho = jethfutilities::slicedPerCandidate(bkgRhos, candidate, perD0CandidateRhos, perLcCandidateRhos, perBplusCandidateRhos).iteratorAt(0);
       TRandom3 randomNumber(0);