From 119e5fcf57d8c85afe0167183cde51c7c15ae959 Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Sun, 15 Feb 2026 00:18:49 +0100 Subject: [PATCH 1/4] Fix geo jet matching: - JE framework got update that fixed the issue with the incorrent matching of det. level MC jets to part. level ones - Extended with new histograms - Added reponse matrices with subtracted rho --- PWGJE/Tasks/recoilJets.cxx | 511 +++++++++++++++++++++++++------------ 1 file changed, 342 insertions(+), 169 deletions(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index b545c092da4..6fc1cf31002 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -44,6 +44,7 @@ #include #include #include +#include using namespace o2; using namespace o2::framework; @@ -51,9 +52,9 @@ using namespace o2::framework::expressions; // Shorthand notations using FilteredColl = soa::Filtered>::iterator; -using FilteredCollPartLevel = soa::Filtered>::iterator; +using FilteredCollPartLevel = soa::Filtered>; using FilteredCollPartLevelMB = soa::Filtered>::iterator; -using FilteredCollDetLevelGetWeight = soa::Filtered>::iterator; +using FilteredCollDetLevelGetWeight = soa::Filtered>; using FilteredEventMultiplicity = soa::Filtered>::iterator; using FilteredEventMultiplicityDetLevelGetWeight = soa::Filtered>::iterator; @@ -157,7 +158,7 @@ struct RecoilJets { std::vector triggerMaskBits; Service pdg; - Preslice partJetsPerCollision = aod::jet::mcCollisionId; + Preslice partJetsPerMcCollision = aod::jet::mcCollisionId; template struct AxisDesc { @@ -444,59 +445,156 @@ struct RecoilJets { } } - // Jet matching: part. vs. det. - if (doprocessJetsMatched || doprocessJetsMatchedWeighted) { - spectra.add("hJetPt_DetLevel_vs_PartLevel", - "Correlation jet pT at det. vs. part. levels", - kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); - - // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel", - // "Correlation jet pT at part. vs. det. levels", - // kTH2F, {jetPTcorr, jetPTcorr}, setSumw2); - - spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", - "Correlation recoil jet pT at part. vs. det. levels", - kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); - // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}, setSumw2); - - spectra.add("hMissedJets_pT", - "Part. level jets w/o matched pair", - kTH1F, {{200, 0.0, 200.}}, setSumw2); - - // spectra.add("hMissedJets_Corr_pT", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}, setSumw2); - spectra.add("hMissedJets_pT_RecoilJets", - "Part. level jets w/o matched pair", - kTH1F, {{200, 0.0, 200.}}, setSumw2); - // spectra.add("hMissedJets_Corr_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}, setSumw2); - - spectra.add("hFakeJets_pT", - "Det. level jets w/o matched pair", - kTH1F, {{200, 0.0, 200.}}, setSumw2); - // spectra.add("hFakeJets_Corr_pT", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}, setSumw2); - spectra.add("hFakeJets_pT_RecoilJets", - "Det. level jets w/o matched pair", - kTH1F, {{200, 0.0, 200.}}, setSumw2); - // spectra.add("hFakeJets_Corr_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}, setSumw2); - - spectra.add("hJetPt_resolution", - "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", - kTH2F, {{100, -5., 5.}, pT}, setSumw2); - - spectra.add("hJetPt_resolution_RecoilJets", - "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", - kTH2F, {{100, -5., 5.}, pT}, setSumw2); - - spectra.add("hJetPhi_resolution", + // Jet matching + if (doprocessJetsGeoMatching || doprocessJetsGeoMatchingWeighted) + { + AxisSpec detJetPt{200, 0.0, 200., "#it{p}_{T, det} (GeV/#it{c})"}; + AxisSpec detJetPtCorr{220, -20.0, 200., "#it{p}_{T, det}^{corr.} (GeV/#it{c})"}; + + AxisSpec partJetPt{200, 0.0, 200., "#it{p}_{T, part} (GeV/#it{c})"}; + AxisSpec partJetPtCorr{220, -20.0, 200., "#it{p}_{T, part}^{corr.} (GeV/#it{c})"}; + + AxisSpec relJetSmearPt{100, -5., 1., "(#it{p}_{T, part} - #it{p}_{T, det}) / #it{p}_{T, part}"}; + + //==================================================================================== + // Part. level jets + spectra.add("hPartLevelInclusiveJetsPt", + "All part. level inclusive jets", + kTH1F, {partJetPt}, setSumw2); + + spectra.add("hPartLevelInclusiveJetsPtCorr", + "All part. level inclusive jets", + kTH1F, {partJetPtCorr}, setSumw2); + + + spectra.add("hPartLevelRecoilJetsPt", + "All part. level recoil jets", + kTH1F, {partJetPt}, setSumw2); + + spectra.add("hPartLevelRecoilJetsPtCorr", + "All part. level recoil jets", + kTH1F, {partJetPtCorr}, setSumw2); + + + spectra.add("hMissedInclusiveJetsPt", + "Part. level inclusive jets w/o matched pair", + kTH1F, {partJetPt}, setSumw2); + + spectra.add("hMissedInclusiveJetsPtCorr", + "Part. level inclusive jets w/o matched pair", + kTH1F, {partJetPtCorr}, setSumw2); + + + spectra.add("hMissedRecoilJetsPt", + "Part. level recoil jets w/o matched pair", + kTH1F, {partJetPt}, setSumw2); + + spectra.add("hMissedRecoilJetsPtCorr", + "Part. level recoil jets w/o matched pair", + kTH1F, {partJetPtCorr}, setSumw2); + + //==================================================================================== + // Det. level jets + spectra.add("hDetLevelInclusiveJetsPt", + "All reconstructed inclusive jets", + kTH1F, {detJetPt}, setSumw2); + + spectra.add("hDetLevelInclusiveJetsPtCorr", + "All reconstructed inclusive jets", + kTH1F, {detJetPtCorr}, setSumw2); + + + spectra.add("hDetLevelRecoilJetsPt", + "All reconstructed recoil jets", + kTH1F, {detJetPt}, setSumw2); + + spectra.add("hDetLevelRecoilJetsPtCorr", + "All reconstructed recoil jets", + kTH1F, {detJetPtCorr}, setSumw2); + + + spectra.add("hFakeInclusiveJetsPt", + "Det. level inclusive jets w/o matched pair", + kTH1F, {detJetPt}, setSumw2); + + spectra.add("hFakeInclusiveJetsPtCorr", + "Det. level inclusive jets w/o matched pair", + kTH1F, {detJetPtCorr}, setSumw2); + + + spectra.add("hFakeRecoilJetsPt", + "Det. level recoil jets w/o matched pair", + kTH1F, {detJetPt}, setSumw2); + + spectra.add("hFakeRecoilJetsPtCorr", + "Det. level recoil jets w/o matched pair", + kTH1F, {detJetPtCorr}, setSumw2); + + //==================================================================================== + // Response matices with inclusive jets + spectra.add("hResponseMatrixInclusiveJetsPt", + "Correlation inclusive #it{p}_{T, det.} vs. #it{p}_{T, part}", + kTH2F, {detJetPt, partJetPt}, setSumw2); + + spectra.add("hResponseMatrixInclusiveJetsPtCorr", + "Correlation inclusive #it{p}_{T, det.} vs. #it{p}_{T, part}", + kTH2F, {detJetPtCorr, partJetPtCorr}, setSumw2); + + + //==================================================================================== + // Response matices with recoil jets + spectra.add("hResponseMatrixRecoilJetsPt", + "Correlation recoil #it{p}_{T, det.} vs. #it{p}_{T, part}", + kTH2F, {detJetPt, partJetPt}, setSumw2); + + spectra.add("hResponseMatrixRecoilJetsPtCorr", + "Correlation recoil #it{p}_{T, det.} vs. #it{p}_{T, part}", + kTH2F, {detJetPtCorr, partJetPtCorr}, setSumw2); + + + //==================================================================================== + // Jet energy scale and resolution: pT and phi + spectra.add("hInclusiveJESPt", + "ES of inclusive jets vs. #it{p}_{T, part}", + kTH2F, {relJetSmearPt, partJetPt}, setSumw2); + + spectra.add("hInclusiveJESPtCorr", + "ES of inclusive jets vs. #it{p}_{T, part}", + kTH2F, {relJetSmearPt, partJetPtCorr}, setSumw2); + + + spectra.add("hRecoilJESPt", + "ES of recoil jets vs. #it{p}_{T, part}", + kTH2F, {relJetSmearPt, partJetPt}, setSumw2); + + spectra.add("hRecoilJESPtCorr", + "ES of recoil jets vs. #it{p}_{T, part}", + kTH2F, {relJetSmearPt, partJetPtCorr}, setSumw2); + + + AxisSpec jetSmearPhi{40, -1., 1., "#it{#varphi}_{part} - #it{#varphi}_{det}"}; + spectra.add("hInclusiveJESPhi", "#varphi resolution as a func. of jet #it{p}_{T, part}", - kTH2F, {{40, -1., 1.}, pT}, setSumw2); + kTH2F, {jetSmearPhi, partJetPt}, setSumw2); - spectra.add("hJetPhi_resolution_RecoilJets", + spectra.add("hRecoilJESPhi", "#varphi resolution as a func. of jet #it{p}_{T, part}", - kTH2F, {{40, -1., 1.}, pT}, setSumw2); + kTH2F, {jetSmearPhi, partJetPt}, setSumw2); - spectra.add("hNumberMatchedJetsPerOneBaseJet", - "# of tagged jets per 1 base jet vs. jet pT", - kTH2F, {{10, 0.5, 10.5}, {100, 0.0, 100.}}, setSumw2); + + //==================================================================================== + // Utility histograms + spectra.add("hNumberMatchedInclusiveDetJetsPerOnePartJet", + "# of det. level inclusive jets per 1 part. level jet vs. #it{p}_{T, det.} vs. #it{p}_{T, part.}", + kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, + {200, 0.0, 200., "#it{p}_{T, det.}"}, + {200, 0.0, 200., "#it{p}_{T, part.}"}}, setSumw2); + + spectra.add("hNumberMatchedRecoilDetJetsPerOnePartJet", + "# of det. level recoil jets per 1 part. level jet vs. #it{p}_{T, det.} vs. #it{p}_{T, part.}", + kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, + {200, 0.0, 200., "#it{p}_{T, det.}"}, + {200, 0.0, 200., "#it{p}_{T, part.}"}}, setSumw2); } // Multiplicity for raw data and detector level MC @@ -836,7 +934,7 @@ struct RecoilJets { for (const auto& jet : jets) { // skip jets which have a constituent with pT above specified cut - if (isJetWithHighPtConstituent(jet, tracks)) + if (isJetWithHighPtConstituent(jet)) continue; float jetPt = jet.pt(); @@ -1040,36 +1138,137 @@ struct RecoilJets { //============================================================================= // Construction of response matrix //============================================================================= - template - void fillMatchedHistograms(JTracksTable const& tracks, - JetsBase const& jetsBase, - JetsTag const& jetsTag, + template + void fillMatchedHistograms(JetsPart const& jetsPart, + JetsDet const& jetsDet, + JTracks const& tracks, + float partLevelCollRho, + float detLevelCollRho, float weight = 1.) - { - std::vector vPhiOfTT; + { + ///TODO: consider TT cand. on both MC levels simultaneously + + // Utilities for recoil jets; TTsis at det. level MC + std::vector vPhiOfTT = getPhiOfAllTTCandidates(tracks); double phiTTSig = 0.0; + bool bIsThereTTSig = vPhiOfTT.size() > 0; - for (const auto& track : tracks) { - if (skipTrack(track)) - continue; + if (bIsThereTTSig) + phiTTSig = getPhiTT(vPhiOfTT); - // Search for TT_Sig candidate - const auto ptTTsigMin = ptTTsig->at(0); - const auto ptTTsigMax = ptTTsig->at(1); - if (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax) { - vPhiOfTT.push_back(track.phi()); + for (const auto& jetPart : jetsPart) + { + auto partJetPt = jetPart.pt(); + auto partJetPtCorr = partJetPt - partLevelCollRho * jetPart.area(); + + bool bIsPartJetRecoil = + get<1>(isRecoilJet(jetPart, phiTTSig)) && bIsThereTTSig; + + // Distribution of all part. level jets + spectra.fill(HIST("hPartLevelInclusiveJetsPt"), partJetPt, weight); + spectra.fill(HIST("hPartLevelInclusiveJetsPtCorr"), partJetPtCorr, weight); + + if (bIsPartJetRecoil) + { + spectra.fill(HIST("hPartLevelRecoilJetsPt"), partJetPt, weight); + spectra.fill(HIST("hPartLevelRecoilJetsPtCorr"), partJetPtCorr, weight); } + + if(jetPart.has_matchedJetGeo()) + { + const auto& jetsDetMatched = jetPart.template matchedJetGeo_as(); + + for (const auto& jetDetMatched : jetsDetMatched) + { + // skip matches where detector level jets have a constituent with pT above specified cut + bool skipMatchedDetJet = isJetWithHighPtConstituent(jetDetMatched); + + if (skipMatchedDetJet) + { + // Miss jets + spectra.fill(HIST("hMissedInclusiveJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedInclusiveJetsPtCorr"), partJetPtCorr, weight); + + if (bIsPartJetRecoil) + { + spectra.fill(HIST("hMissedRecoilJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedRecoilJetsPtCorr"), partJetPtCorr, weight); + } + + } else { + auto detJetPt = jetDetMatched.pt(); + auto detJetPtCorr = detJetPt - detLevelCollRho * jetDetMatched.area(); + + spectra.fill(HIST("hNumberMatchedInclusiveDetJetsPerOnePartJet"), jetsDetMatched.size(), detJetPt, partJetPt, weight); + + spectra.fill(HIST("hResponseMatrixInclusiveJetsPt"), detJetPt, partJetPt, weight); + spectra.fill(HIST("hResponseMatrixInclusiveJetsPtCorr"), detJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hInclusiveJESPt"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hInclusiveJESPtCorr"), (partJetPtCorr - detJetPtCorr) / partJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hInclusiveJESPhi"), jetPart.phi() - jetDetMatched.phi(), partJetPt, weight); + + if (bIsPartJetRecoil) + { + spectra.fill(HIST("hNumberMatchedRecoilDetJetsPerOnePartJet"), jetsDetMatched.size(), detJetPt, partJetPt, weight); + + spectra.fill(HIST("hResponseMatrixRecoilJetsPt"), detJetPt, partJetPt, weight); + spectra.fill(HIST("hResponseMatrixRecoilJetsPtCorr"), detJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hRecoilJESPt"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hRecoilJESPtCorr"), (partJetPtCorr - detJetPtCorr) / partJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hRecoilJESPhi"), jetPart.phi() - jetDetMatched.phi(), partJetPt, weight); + } + } + } + } else { + // Miss jets + spectra.fill(HIST("hMissedInclusiveJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedInclusiveJetsPtCorr"), partJetPtCorr, weight); + + if (bIsPartJetRecoil) + { + spectra.fill(HIST("hMissedRecoilJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedRecoilJetsPtCorr"), partJetPtCorr, weight); + } + } } - bool bIsThereTTSig = vPhiOfTT.size() > 0; + // Reconstructed jets + for (const auto& jetDet : jetsDet) + { + if (isJetWithHighPtConstituent(jetDet)) + continue; - if (bIsThereTTSig) - phiTTSig = getPhiTT(vPhiOfTT); + auto detJetPt = jetDet.pt(); + auto detJetPtCorr = detJetPt - detLevelCollRho * jetDet.area(); + + bool bIsJetRecoil = + get<1>(isRecoilJet(jetDet, phiTTSig)) && bIsThereTTSig; - for (const auto& jetBase : jetsBase) { - bool bIsBaseJetRecoil = - get<1>(isRecoilJet(jetBase, phiTTSig)) && bIsThereTTSig; - dataForUnfolding(jetBase, jetsTag, bIsBaseJetRecoil, tracks, weight); + // Distribution of all det. level jets + spectra.fill(HIST("hDetLevelInclusiveJetsPt"), detJetPt, weight); + spectra.fill(HIST("hDetLevelInclusiveJetsPtCorr"), detJetPtCorr, weight); + + if (bIsJetRecoil) + { + spectra.fill(HIST("hDetLevelRecoilJetsPt"), detJetPt, weight); + spectra.fill(HIST("hDetLevelRecoilJetsPtCorr"), detJetPtCorr, weight); + } + + if (!jetDet.has_matchedJetGeo()) + { + spectra.fill(HIST("hFakeInclusiveJetsPt"), detJetPt, weight); + spectra.fill(HIST("hFakeInclusiveJetsPtCorr"), detJetPtCorr, weight); + + if (bIsJetRecoil) + { + spectra.fill(HIST("hFakeRecoilJetsPt"), detJetPt, weight); + spectra.fill(HIST("hFakeRecoilJetsPtCorr"), detJetPtCorr, weight); + } + } } } @@ -1148,7 +1347,7 @@ struct RecoilJets { } //============================================================================= - // Event Activity QA analysis in OO collisions (raw and MC detector level (no weight)) + // Event Activity QA analysis in OO collisions (raw and MC detector level (no weight; MB events)) //============================================================================= template void fillMultiplicityQA(Collision const& collision, @@ -1289,7 +1488,7 @@ struct RecoilJets { } //============================================================================= - // Di-hadron azimuthal correlation in raw and MC det. level (no weight) data + // Di-hadron azimuthal correlation in raw and MC det. level (no weight; MB events) data //============================================================================= template void fillLeadingAndAssociatedTracksTask(JCollision const& collision, JTracks const& tracks, float weight = 1.) @@ -1764,10 +1963,10 @@ struct RecoilJets { spectra.fill(HIST("hEventSelectionCount"), 4.5); // number of events selected for analysis fillHistograms(collision, jets, tracks); } - PROCESS_SWITCH(RecoilJets, processMCDetLevel, "process MC det. level data (no weight)", false); + PROCESS_SWITCH(RecoilJets, processMCDetLevel, "process MC det. level data (no weight; MB events)", false); //____________________________ - void processMCDetLevelWeighted(FilteredCollDetLevelGetWeight const& collision, + void processMCDetLevelWeighted(FilteredCollDetLevelGetWeight::iterator const& collision, aod::JetMcCollisions const&, FilteredTracks const& tracks, FilteredJetsDetLevel const& jets) @@ -1792,7 +1991,7 @@ struct RecoilJets { auto weight = collision.mcCollision().weight(); fillHistograms(collision, jets, tracks, weight); } - PROCESS_SWITCH(RecoilJets, processMCDetLevelWeighted, "process MC det. level data (weighted)", false); + PROCESS_SWITCH(RecoilJets, processMCDetLevelWeighted, "process MC det. level data (weighted JJ)", false); //_____________________ void processMCPartLevel(FilteredCollPartLevelMB const& collision, @@ -1809,10 +2008,10 @@ struct RecoilJets { spectra.fill(HIST("hEventSelectionCountPartLevel"), 3.5); // number of events selected for analysis fillHistogramsMCPartLevel(collision, jets, particles); } - PROCESS_SWITCH(RecoilJets, processMCPartLevel, "process MC part. level data (no weight)", false); + PROCESS_SWITCH(RecoilJets, processMCPartLevel, "process MC part. level data (no weight; MB events)", false); //_____________________________ - void processMCPartLevelWeighted(FilteredCollPartLevel const& collision, + void processMCPartLevelWeighted(FilteredCollPartLevel::iterator const& collision, FilteredParticles const& particles, FilteredJetsPartLevel const& jets) { @@ -1834,45 +2033,57 @@ struct RecoilJets { spectra.fill(HIST("ptHat"), collision.ptHard(), weight); fillHistogramsMCPartLevel(collision, jets, particles, weight); } - PROCESS_SWITCH(RecoilJets, processMCPartLevelWeighted, "process MC part. level data (weighted)", false); + PROCESS_SWITCH(RecoilJets, processMCPartLevelWeighted, "process MC part. level data (weighted JJ)", false); //============================================================================= // Construction of response matrix //============================================================================= - void processJetsMatched(soa::Filtered>::iterator const& collision, - aod::JetMcCollisions const&, - FilteredTracks const& tracks, - FilteredMatchedJetsDetLevel const& mcdjets, - FilteredMatchedJetsPartLevel const& mcpjets) + void processJetsGeoMatching(soa::Filtered>::iterator const& collision, + soa::Filtered> const& mcCollisions, + FilteredTracks const& tracksPerColl, + FilteredMatchedJetsDetLevel const& mcDetJetsPerColl, + FilteredMatchedJetsPartLevel const& mcPartJets) { - if (skipEvent(collision)) + // Skip detector level collisions + if (skipEvent(collision) || !collision.has_mcCollision()) return; - auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); + auto mcCollisionId = collision.mcCollisionId(); + auto detLevelCollRho = collision.rho(); + auto partLevelCollRho = mcCollisions.iteratorAt(mcCollisionId).rho(); - fillMatchedHistograms(tracks, mcpjetsPerMCCollision, mcdjets); - } - PROCESS_SWITCH(RecoilJets, processJetsMatched, "process matching of MC jets (no weight)", false); + // Slice for mc part level jets associated to a given mcCollisionId + auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) - //_____________________________ - void processJetsMatchedWeighted(FilteredCollDetLevelGetWeight const& collision, - aod::JetMcCollisions const&, - FilteredTracks const& tracks, - FilteredMatchedJetsDetLevel const& mcdjets, - FilteredMatchedJetsPartLevel const& mcpjets) + fillMatchedHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho); + } + PROCESS_SWITCH(RecoilJets, processJetsGeoMatching, "process matching of MC jets using Geo criterion (no weight; MB events)", false); + + //_________________________________ + void processJetsGeoMatchingWeighted(FilteredCollDetLevelGetWeight::iterator const& collision, + soa::Filtered> const& mcCollisions, + FilteredTracks const& tracksPerColl, + FilteredMatchedJetsDetLevel const& mcDetJetsPerColl, + FilteredMatchedJetsPartLevel const& mcPartJets) { + // Skip detector level collisions if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) return; - auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); - auto weight = collision.mcCollision().weight(); + auto mcCollisionId = collision.mcCollisionId(); + auto detLevelCollRho = collision.rho(); + auto partLevelCollRho = mcCollisions.iteratorAt(mcCollisionId).rho(); + auto weight = mcCollisions.iteratorAt(mcCollisionId).weight(); - fillMatchedHistograms(tracks, mcpjetsPerMCCollision, mcdjets, weight); + // Slice for mc part level jets associated to a given mcCollisionId + auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) + + fillMatchedHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho, weight); } - PROCESS_SWITCH(RecoilJets, processJetsMatchedWeighted, "process matching of MC jets (weighted)", false); + PROCESS_SWITCH(RecoilJets, processJetsGeoMatchingWeighted, "process matching of MC jets using Geo criterion (weighted JJ)", false); //============================================================================= - // Event Activity analysis in OO collisions (raw and MC detector level (no weight)) + // Event Activity analysis in OO collisions (raw and MC detector level (no weight; MB events)) //============================================================================= void processEventActivityOO(FilteredEventMultiplicity const& collision) { @@ -1881,7 +2092,7 @@ struct RecoilJets { fillMultiplicityHistogramsOO(collision); } - PROCESS_SWITCH(RecoilJets, processEventActivityOO, "process event activity in OO collisions and MC det. level (no weight)", false); + PROCESS_SWITCH(RecoilJets, processEventActivityOO, "process event activity in OO collisions and MC det. level (no weight; MB events)", false); //___________________________________________ void processEventActivityMCDetLevelWeightedOO(FilteredEventMultiplicityDetLevelGetWeight const& collision, @@ -1893,7 +2104,7 @@ struct RecoilJets { auto weight = collision.mcCollision().weight(); fillMultiplicityHistogramsOO(collision, weight); } - PROCESS_SWITCH(RecoilJets, processEventActivityMCDetLevelWeightedOO, "process event activity in MC det. level OO collisions (weighted)", false); + PROCESS_SWITCH(RecoilJets, processEventActivityMCDetLevelWeightedOO, "process event activity in MC det. level OO collisions (weighted JJ)", false); //============================================================================= // Event Activity analysis in OO and pp collisions at Particle level @@ -1905,7 +2116,7 @@ struct RecoilJets { fillMultiplicityHistogramsMCPartLevel(collision); } - PROCESS_SWITCH(RecoilJets, processEventActivityMCPartLevel, "process event activity in MC part. level events (no weight)", false); + PROCESS_SWITCH(RecoilJets, processEventActivityMCPartLevel, "process event activity in MC part. level events (no weight; MB events)", false); //__________________________________________ void processEventActivityMCPartLevelWeighted(FilteredEventMultiplicityPartLevel const& collision) @@ -1916,10 +2127,10 @@ struct RecoilJets { auto weight = collision.weight(); fillMultiplicityHistogramsMCPartLevel(collision, weight); } - PROCESS_SWITCH(RecoilJets, processEventActivityMCPartLevelWeighted, "process event activity in MC part. level events (weighted)", false); + PROCESS_SWITCH(RecoilJets, processEventActivityMCPartLevelWeighted, "process event activity in MC part. level events (weighted JJ)", false); //============================================================================= - // Event Activity QA analysis in OO collisions (raw and MC detector level (no weight)) + // Event Activity QA analysis in OO collisions (raw and MC detector level (no weight; MB events)) //============================================================================= void processEventActivityQA(ColEvSelEA const& collision, BCsRun3 const& BCs, @@ -1931,10 +2142,10 @@ struct RecoilJets { fillMultiplicityQA(collision, BCs, ZDCs); } - PROCESS_SWITCH(RecoilJets, processEventActivityQA, "process function for EA QA purposes in raw and MC det. level (no weight) data", false); + PROCESS_SWITCH(RecoilJets, processEventActivityQA, "process function for EA QA purposes in raw and MC det. level (no weight; MB events) data", false); //============================================================================= - // Di-hadron azimuthal correlation in raw and MC det. level (no weight) data + // Di-hadron azimuthal correlation in raw and MC det. level (no weight; MB events) data //============================================================================= void processLeadingAndAssociatedTracksTask(soa::Filtered::iterator const& collision, FilteredTracks const& tracks) @@ -1943,7 +2154,7 @@ struct RecoilJets { return; fillLeadingAndAssociatedTracksTask(collision, tracks); } - PROCESS_SWITCH(RecoilJets, processLeadingAndAssociatedTracksTask, "process di-hadron azimuthal correlation in raw and MC det. level (no weight) data", false); + PROCESS_SWITCH(RecoilJets, processLeadingAndAssociatedTracksTask, "process di-hadron azimuthal correlation in raw and MC det. level (no weight; MB events) data", false); //============================================================================= // Estimation of bkgd fluctuations @@ -1969,10 +2180,10 @@ struct RecoilJets { fillBkgdFluctuations(collision, jets, tracks); } - PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevel, "process MC det. level (no weight) data to estimate bkgd fluctuations", false); + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevel, "process MC det. level (no weight; MB events) data to estimate bkgd fluctuations", false); //____________________________________________ - void processBkgdFluctuationsMCDetLevelWeighted(FilteredCollDetLevelGetWeight const& collision, + void processBkgdFluctuationsMCDetLevelWeighted(FilteredCollDetLevelGetWeight::iterator const& collision, aod::JetMcCollisions const&, FilteredTracks const& tracks, FilteredJetsDetLevel const& jets) @@ -1983,7 +2194,7 @@ struct RecoilJets { auto weight = collision.mcCollision().weight(); fillBkgdFluctuations(collision, jets, tracks, weight); } - PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevelWeighted, "process MC det. level (weighted) data to estimate bkgd fluctuations", false); + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevelWeighted, "process MC det. level (weighted JJ) data to estimate bkgd fluctuations", false); //_____________________________________ void processBkgdFluctuationsMCPartLevel(FilteredCollPartLevelMB const& collision, @@ -1995,10 +2206,10 @@ struct RecoilJets { fillBkgdFluctuationsMCPartLevel(collision, jets, particles); } - PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevel, "process MC part. level (no weight) data to estimate bkgd fluctuations", false); + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevel, "process MC part. level (no weight; MB events) data to estimate bkgd fluctuations", false); //_____________________________________________ - void processBkgdFluctuationsMCPartLevelWeighted(FilteredCollPartLevel const& collision, + void processBkgdFluctuationsMCPartLevelWeighted(FilteredCollPartLevel::iterator const& collision, FilteredParticles const& particles, FilteredJetsPartLevel const& jets) { @@ -2008,7 +2219,7 @@ struct RecoilJets { auto weight = collision.weight(); fillBkgdFluctuationsMCPartLevel(collision, jets, particles, weight); } - PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevelWeighted, "process MC part. level (weighted) data to estimate bkgd fluctuations", false); + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevelWeighted, "process MC part. level (weighted JJ) data to estimate bkgd fluctuations", false); //------------------------------------------------------------------------------ // Auxiliary functions @@ -2065,8 +2276,8 @@ struct RecoilJets { return 0.5 * (scaledMultFT0A + scaledMultFT0C); } - template - bool isJetWithHighPtConstituent(Jet const& jet, Tracks const&) + template + bool isJetWithHighPtConstituent(Jet const& jet) { bool bIsJetWithHighPtConstituent = false; for (const auto& jetConstituent : jet.template tracks_as()) { @@ -2108,62 +2319,24 @@ struct RecoilJets { return binNumber; } - - template - void dataForUnfolding(PartJet const& partJet, DetJet const& detJets, - bool bIsBaseJetRecoil, TracksTable const& tracks, float weight = 1.) + + template + std::vector getPhiOfAllTTCandidates(JTracksTable const& tracks) { + std::vector vPhiOfTT; - float partJetPt = partJet.pt(); - bool bIsThereMatchedJet = partJet.has_matchedJetGeo(); - - if (bIsThereMatchedJet) { - const auto& jetsMatched = partJet.template matchedJetGeo_as>(); - - for (const auto& jetMatched : jetsMatched) { - - // skip matches where detector level jets have a constituent with pT above specified cut - bool skipMatchedDetJet = isJetWithHighPtConstituent(jetMatched, tracks); - - if (skipMatchedDetJet) { - // Miss jets - spectra.fill(HIST("hMissedJets_pT"), partJetPt, weight); - if (bIsBaseJetRecoil) - spectra.fill(HIST("hMissedJets_pT_RecoilJets"), partJetPt, weight); - } else { - float detJetPt = jetMatched.pt(); - - spectra.fill(HIST("hNumberMatchedJetsPerOneBaseJet"), jetsMatched.size(), detJetPt, weight); - spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel"), detJetPt, partJetPt, weight); - spectra.fill(HIST("hJetPt_resolution"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); - spectra.fill(HIST("hJetPhi_resolution"), partJet.phi() - jetMatched.phi(), partJetPt, weight); - - if (bIsBaseJetRecoil) { - spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel_RecoilJets"), detJetPt, partJetPt, weight); - spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); - spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), partJet.phi() - jetMatched.phi(), partJetPt, weight); - } - } - } - } else { - // Miss jets - spectra.fill(HIST("hMissedJets_pT"), partJetPt, weight); - if (bIsBaseJetRecoil) - spectra.fill(HIST("hMissedJets_pT_RecoilJets"), partJetPt, weight); - } - - // Fake jets - for (const auto& detJet : detJets) { - if (isJetWithHighPtConstituent(detJet, tracks)) + for (const auto& track : tracks) { + if (skipTrack(track)) continue; - bIsThereMatchedJet = detJet.has_matchedJetGeo(); - if (!bIsThereMatchedJet) { - spectra.fill(HIST("hFakeJets_pT"), detJet.pt(), weight); - if (bIsBaseJetRecoil) - spectra.fill(HIST("hFakeJets_pT_RecoilJets"), detJet.pt(), weight); + // Search for TT_Sig candidate + const auto ptTTsigMin = ptTTsig->at(0); + const auto ptTTsigMax = ptTTsig->at(1); + if (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax) { + vPhiOfTT.emplace_back(track.phi()); } } + return vPhiOfTT; } template From 08a3511399ad77092352456dd74ea326b351d50c Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Sun, 15 Feb 2026 01:12:59 +0100 Subject: [PATCH 2/4] Clean-up aliases for tables --- PWGJE/Tasks/recoilJets.cxx | 170 ++++++++++++++++++++----------------- 1 file changed, 93 insertions(+), 77 deletions(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index 6fc1cf31002..bee64617983 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -51,28 +51,44 @@ using namespace o2::framework; using namespace o2::framework::expressions; // Shorthand notations -using FilteredColl = soa::Filtered>::iterator; -using FilteredCollPartLevel = soa::Filtered>; -using FilteredCollPartLevelMB = soa::Filtered>::iterator; -using FilteredCollDetLevelGetWeight = soa::Filtered>; -using FilteredEventMultiplicity = soa::Filtered>::iterator; -using FilteredEventMultiplicityDetLevelGetWeight = soa::Filtered>::iterator; -using FilteredEventMultiplicityPartLevel = soa::Filtered>::iterator; -using FilteredEventMultiplicityPartLevelMB = soa::Filtered::iterator; +// --- Collisions (+ rho) +using CollDataIt = soa::Filtered::iterator; +using CollRhoDataIt = soa::Filtered>::iterator; +using CollRhoOutlierDetIt = soa::Filtered>::iterator; +using CollRhoDetIt = soa::Filtered>::iterator; -using FilteredJets = soa::Filtered>; -using FilteredJetsDetLevel = soa::Filtered>; -using FilteredJetsPartLevel = soa::Filtered>; +using CollPartIt = soa::Filtered::iterator; +using CollRhoPartTbl = soa::Filtered>; +using CollRhoPartIt = soa::Filtered>::iterator; +using CollRhoOutlierPartIt = soa::Filtered>::iterator; +using CollRhoOutlierPartTbl = soa::Filtered>; -using FilteredMatchedJetsDetLevel = soa::Filtered>; -using FilteredMatchedJetsPartLevel = soa::Filtered>; -using FilteredTracks = soa::Filtered; -using FilteredParticles = soa::Filtered; +// --- Event multiplicity (+ ZDC etc.) +using EvMultZDCDataIt = soa::Filtered>::iterator; +using EvMultOutlierZDCDetIt = soa::Filtered>::iterator; +using EvMultOutlierPartIt = soa::Filtered>::iterator; -using ColEvSelEA = soa::Filtered>::iterator; -using BCsRun3 = soa::Join; // aod::Run3MatchedToBCExclusive + +// --- Tracks / Particles +using TrackTbl = soa::Filtered; +using PartTbl = soa::Filtered; + + +// --- Jets (with constituents) +using JetsDataTbl = soa::Filtered>; +using JetsDetTbl = soa::Filtered>; +using JetsPartTbl = soa::Filtered>; + +// --- Matched jets (det <-> part) +using MatchedJetsDetToPartTbl = soa::Filtered>; +using MatchedJetsPartToDetTbl = soa::Filtered>; + + +// --- O2 collisions event selection (not JCollisions) +using CollEvSelExtendedIt = soa::Filtered>::iterator; +using BCsRun3Tbl = soa::Join; // aod::Run3MatchedToBCExclusive struct RecoilJets { @@ -158,7 +174,7 @@ struct RecoilJets { std::vector triggerMaskBits; Service pdg; - Preslice partJetsPerMcCollision = aod::jet::mcCollisionId; + Preslice partJetsPerMcCollision = aod::jet::mcCollisionId; template struct AxisDesc { @@ -1934,9 +1950,9 @@ struct RecoilJets { //============================================================================= // Recoil jet analysis //============================================================================= - void processData(FilteredColl const& collision, - FilteredTracks const& tracks, - FilteredJets const& jets) + void processData(CollRhoDataIt const& collision, + TrackTbl const& tracksPerColl, + JetsDataTbl const& jetsPerColl) { spectra.fill(HIST("hEventSelectionCount"), 0.5); @@ -1945,14 +1961,14 @@ struct RecoilJets { spectra.fill(HIST("hEventSelectionCount"), 1.5); // number of events selected for analysis - fillHistograms(collision, jets, tracks); + fillHistograms(collision, jetsPerColl, tracksPerColl); } PROCESS_SWITCH(RecoilJets, processData, "process raw data", true); //____________________ - void processMCDetLevel(FilteredColl const& collision, - FilteredTracks const& tracks, - FilteredJetsDetLevel const& jets) + void processMCDetLevel(CollRhoDataIt const& collision, + TrackTbl const& tracksPerColl, + JetsDetTbl const& jetsPerColl) { spectra.fill(HIST("hEventSelectionCount"), 0.5); if (skipEvent(collision)) @@ -1961,15 +1977,15 @@ struct RecoilJets { spectra.fill(HIST("hEventSelectionCount"), 1.5); spectra.fill(HIST("hEventSelectionCount"), 4.5); // number of events selected for analysis - fillHistograms(collision, jets, tracks); + fillHistograms(collision, jetsPerColl, tracksPerColl); } PROCESS_SWITCH(RecoilJets, processMCDetLevel, "process MC det. level data (no weight; MB events)", false); //____________________________ - void processMCDetLevelWeighted(FilteredCollDetLevelGetWeight::iterator const& collision, + void processMCDetLevelWeighted(CollRhoOutlierDetIt const& collision, aod::JetMcCollisions const&, - FilteredTracks const& tracks, - FilteredJetsDetLevel const& jets) + TrackTbl const& tracksPerColl, + JetsDetTbl const& jetsPerColl) { spectra.fill(HIST("hEventSelectionCount"), 0.5); if (skipEvent(collision)) @@ -1989,14 +2005,14 @@ struct RecoilJets { spectra.fill(HIST("hEventSelectionCount"), 4.5); // number of events selected for analysis auto weight = collision.mcCollision().weight(); - fillHistograms(collision, jets, tracks, weight); + fillHistograms(collision, jetsPerColl, tracksPerColl, weight); } PROCESS_SWITCH(RecoilJets, processMCDetLevelWeighted, "process MC det. level data (weighted JJ)", false); //_____________________ - void processMCPartLevel(FilteredCollPartLevelMB const& collision, - FilteredParticles const& particles, - FilteredJetsPartLevel const& jets) + void processMCPartLevel(CollRhoPartIt const& collision, + PartTbl const& particlesPerColl, + JetsPartTbl const& jetsPerColl) { spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5); @@ -2006,14 +2022,14 @@ struct RecoilJets { } spectra.fill(HIST("hEventSelectionCountPartLevel"), 3.5); // number of events selected for analysis - fillHistogramsMCPartLevel(collision, jets, particles); + fillHistogramsMCPartLevel(collision, jetsPerColl, particlesPerColl); } PROCESS_SWITCH(RecoilJets, processMCPartLevel, "process MC part. level data (no weight; MB events)", false); //_____________________________ - void processMCPartLevelWeighted(FilteredCollPartLevel::iterator const& collision, - FilteredParticles const& particles, - FilteredJetsPartLevel const& jets) + void processMCPartLevelWeighted(CollRhoOutlierPartIt const& collision, + PartTbl const& particlesPerColl, + JetsPartTbl const& jetsPerColl) { spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5); @@ -2031,18 +2047,18 @@ struct RecoilJets { auto weight = collision.weight(); spectra.fill(HIST("ptHat"), collision.ptHard(), weight); - fillHistogramsMCPartLevel(collision, jets, particles, weight); + fillHistogramsMCPartLevel(collision, jetsPerColl, particlesPerColl, weight); } PROCESS_SWITCH(RecoilJets, processMCPartLevelWeighted, "process MC part. level data (weighted JJ)", false); //============================================================================= // Construction of response matrix //============================================================================= - void processJetsGeoMatching(soa::Filtered>::iterator const& collision, - soa::Filtered> const& mcCollisions, - FilteredTracks const& tracksPerColl, - FilteredMatchedJetsDetLevel const& mcDetJetsPerColl, - FilteredMatchedJetsPartLevel const& mcPartJets) + void processJetsGeoMatching(CollRhoDetIt const& collision, + CollRhoPartTbl const& mcCollisions, + TrackTbl const& tracksPerColl, + MatchedJetsDetToPartTbl const& mcDetJetsPerColl, + MatchedJetsPartToDetTbl const& mcPartJets) { // Skip detector level collisions if (skipEvent(collision) || !collision.has_mcCollision()) @@ -2060,11 +2076,11 @@ struct RecoilJets { PROCESS_SWITCH(RecoilJets, processJetsGeoMatching, "process matching of MC jets using Geo criterion (no weight; MB events)", false); //_________________________________ - void processJetsGeoMatchingWeighted(FilteredCollDetLevelGetWeight::iterator const& collision, - soa::Filtered> const& mcCollisions, - FilteredTracks const& tracksPerColl, - FilteredMatchedJetsDetLevel const& mcDetJetsPerColl, - FilteredMatchedJetsPartLevel const& mcPartJets) + void processJetsGeoMatchingWeighted(CollRhoOutlierDetIt const& collision, + CollRhoOutlierPartTbl const& mcCollisions, + TrackTbl const& tracksPerColl, + MatchedJetsDetToPartTbl const& mcDetJetsPerColl, + MatchedJetsPartToDetTbl const& mcPartJets) { // Skip detector level collisions if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) @@ -2085,7 +2101,7 @@ struct RecoilJets { //============================================================================= // Event Activity analysis in OO collisions (raw and MC detector level (no weight; MB events)) //============================================================================= - void processEventActivityOO(FilteredEventMultiplicity const& collision) + void processEventActivityOO(EvMultZDCDataIt const& collision) { if (skipEvent(collision)) return; @@ -2095,7 +2111,7 @@ struct RecoilJets { PROCESS_SWITCH(RecoilJets, processEventActivityOO, "process event activity in OO collisions and MC det. level (no weight; MB events)", false); //___________________________________________ - void processEventActivityMCDetLevelWeightedOO(FilteredEventMultiplicityDetLevelGetWeight const& collision, + void processEventActivityMCDetLevelWeightedOO(EvMultOutlierZDCDetIt const& collision, aod::JetMcCollisions const&) { if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) @@ -2109,7 +2125,7 @@ struct RecoilJets { //============================================================================= // Event Activity analysis in OO and pp collisions at Particle level //============================================================================= - void processEventActivityMCPartLevel(FilteredEventMultiplicityPartLevelMB const& collision) + void processEventActivityMCPartLevel(CollPartIt const& collision) { if (skipMCEvent(collision)) return; @@ -2119,7 +2135,7 @@ struct RecoilJets { PROCESS_SWITCH(RecoilJets, processEventActivityMCPartLevel, "process event activity in MC part. level events (no weight; MB events)", false); //__________________________________________ - void processEventActivityMCPartLevelWeighted(FilteredEventMultiplicityPartLevel const& collision) + void processEventActivityMCPartLevelWeighted(EvMultOutlierPartIt const& collision) { if (skipMCEvent(collision) || collision.isOutlier()) return; @@ -2132,8 +2148,8 @@ struct RecoilJets { //============================================================================= // Event Activity QA analysis in OO collisions (raw and MC detector level (no weight; MB events)) //============================================================================= - void processEventActivityQA(ColEvSelEA const& collision, - BCsRun3 const& BCs, + void processEventActivityQA(CollEvSelExtendedIt const& collision, + BCsRun3Tbl const& BCs, aod::Zdcs const& ZDCs) { // Base flag for event selection @@ -2147,77 +2163,77 @@ struct RecoilJets { //============================================================================= // Di-hadron azimuthal correlation in raw and MC det. level (no weight; MB events) data //============================================================================= - void processLeadingAndAssociatedTracksTask(soa::Filtered::iterator const& collision, - FilteredTracks const& tracks) + void processLeadingAndAssociatedTracksTask(CollDataIt const& collision, + TrackTbl const& tracksPerColl) { if (skipEvent(collision)) return; - fillLeadingAndAssociatedTracksTask(collision, tracks); + fillLeadingAndAssociatedTracksTask(collision, tracksPerColl); } PROCESS_SWITCH(RecoilJets, processLeadingAndAssociatedTracksTask, "process di-hadron azimuthal correlation in raw and MC det. level (no weight; MB events) data", false); //============================================================================= // Estimation of bkgd fluctuations //============================================================================= - void processBkgdFluctuations(FilteredColl const& collision, - FilteredTracks const& tracks, - FilteredJets const& jets) + void processBkgdFluctuations(CollRhoDataIt const& collision, + TrackTbl const& tracksPerColl, + JetsDataTbl const& jetsPerColl) { if (skipEvent(collision)) return; - fillBkgdFluctuations(collision, jets, tracks); + fillBkgdFluctuations(collision, jetsPerColl, tracksPerColl); } PROCESS_SWITCH(RecoilJets, processBkgdFluctuations, "process raw data to estimate bkgd fluctuations", false); //____________________________________ - void processBkgdFluctuationsMCDetLevel(FilteredColl const& collision, - FilteredTracks const& tracks, - FilteredJetsDetLevel const& jets) + void processBkgdFluctuationsMCDetLevel(CollRhoDataIt const& collision, + TrackTbl const& tracksPerColl, + JetsDetTbl const& jetsPerColl) { if (skipEvent(collision)) return; - fillBkgdFluctuations(collision, jets, tracks); + fillBkgdFluctuations(collision, jetsPerColl, tracksPerColl); } PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevel, "process MC det. level (no weight; MB events) data to estimate bkgd fluctuations", false); //____________________________________________ - void processBkgdFluctuationsMCDetLevelWeighted(FilteredCollDetLevelGetWeight::iterator const& collision, + void processBkgdFluctuationsMCDetLevelWeighted(CollRhoOutlierDetIt const& collision, aod::JetMcCollisions const&, - FilteredTracks const& tracks, - FilteredJetsDetLevel const& jets) + TrackTbl const& tracksPerColl, + JetsDetTbl const& jetsPerColl) { if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) return; auto weight = collision.mcCollision().weight(); - fillBkgdFluctuations(collision, jets, tracks, weight); + fillBkgdFluctuations(collision, jetsPerColl, tracksPerColl, weight); } PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevelWeighted, "process MC det. level (weighted JJ) data to estimate bkgd fluctuations", false); //_____________________________________ - void processBkgdFluctuationsMCPartLevel(FilteredCollPartLevelMB const& collision, - FilteredParticles const& particles, - FilteredJetsPartLevel const& jets) + void processBkgdFluctuationsMCPartLevel(CollRhoPartIt const& collision, + PartTbl const& particlesPerColl, + JetsPartTbl const& jetsPerColl) { if (skipMCEvent(collision)) return; - fillBkgdFluctuationsMCPartLevel(collision, jets, particles); + fillBkgdFluctuationsMCPartLevel(collision, jetsPerColl, particlesPerColl); } PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevel, "process MC part. level (no weight; MB events) data to estimate bkgd fluctuations", false); //_____________________________________________ - void processBkgdFluctuationsMCPartLevelWeighted(FilteredCollPartLevel::iterator const& collision, - FilteredParticles const& particles, - FilteredJetsPartLevel const& jets) + void processBkgdFluctuationsMCPartLevelWeighted(CollRhoOutlierPartIt const& collision, + PartTbl const& particlesPerColl, + JetsPartTbl const& jetsPerColl) { if (skipMCEvent(collision) || collision.isOutlier()) return; auto weight = collision.weight(); - fillBkgdFluctuationsMCPartLevel(collision, jets, particles, weight); + fillBkgdFluctuationsMCPartLevel(collision, jetsPerColl, particlesPerColl, weight); } PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevelWeighted, "process MC part. level (weighted JJ) data to estimate bkgd fluctuations", false); From dd60f158d766cd63176bfef49f4b074616374b02 Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Sun, 15 Feb 2026 23:26:55 +0100 Subject: [PATCH 3/4] Group configurables into the logical sections: event selection, track selection, jet selection, etc. It simplifies the code and makes easier to maintain the code and add new configurables --- PWGJE/Tasks/recoilJets.cxx | 550 +++++++++++++++++++++---------------- 1 file changed, 306 insertions(+), 244 deletions(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index bee64617983..31fc8e3433d 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -45,6 +45,7 @@ #include #include #include +#include using namespace o2; using namespace o2::framework; @@ -93,79 +94,140 @@ using BCsRun3Tbl = soa::Join evSel{"evSel", "sel8", "Choose event selection"}; - Configurable trkSel{"trkSel", "globalTracks", "Set track selection"}; - Configurable vertexZCut{"vertexZCut", 10., "Accepted z-vertex range"}; - Configurable fracSig{"fracSig", 0.9, "Fraction of events to use for signal TT"}; - Configurable setSumw2{"setSumw2", false, "Enable Sum2w() calculation for histograms"}; - Configurable trkPtMin{"trkPtMin", 0.15, "Minimum pT of acceptanced tracks"}; - Configurable trkPtMax{"trkPtMax", 100., "Maximum pT of acceptanced tracks"}; + // ---------- Event selection ---------- + struct EvCfg : ConfigurableGroup + { + std::string prefix = "event"; + Configurable sel{"sel", "sel8", "Choose event selection"}, + triggerMasks{"triggerMasks", "", "Relevant trigger masks: fTrackLowPt,fTrackHighPt"}; + + Configurable vertexZCut{"vertexZCut", 10., "Accepted z-vertex range"}; + Configurable skipMBGapEvents{"skipMBGapEvents", false, + "Flag to choose to reject min. bias gap events; jet-level rejection " + "applied at the jet finder level, here rejection is applied for " + "collision and track process functions"}; + } ev; + + + // ---------- RCT / flag-based selections ---------- + struct Rct : ConfigurableGroup + { + std::string prefix = "rct"; + Configurable label{"label", "CBT_hadronPID", "Apply rct flag"}; // CBT + + Configurable enable{"enable", true, "Apply RCT selections"}, + requireZDC{"requireZDC", false, "Require ZDC flag"}, + rejectLimitedAcceptance{"rejectLimitedAcceptance", false, "Reject LimitedAcceptance flag"}; + } rct; + + + // ---------- Track selection ---------- + struct Trk : ConfigurableGroup + { + std::string prefix = "track"; + Configurable sel{"sel", "globalTracks", "Set track selection"}; + + Configurable ptMin{"ptMin", 0.15, "Minimum pT of acceptanced tracks"}, + ptMax{"ptMax", 100., "Maximum pT of acceptanced tracks"}, + etaCut{"etaCut", 0.9, "Eta acceptance of TPC"}; + } trk; + + + // ---------- Jet reconstruction ---------- + struct Jet : ConfigurableGroup + { + std::string prefix = "jet"; + Configurable constituentPtMax{"constituentPtMax", 100., "Remove jets with constituent above this pT cut"}, + radius{"radius", 0.4, "Jet cone radius"}; + } jet; + + + // ---------- Background tools ---------- + struct Bkgd : ConfigurableGroup { + std::string prefix = "bkgd"; + + // Random cone method + Configurable randomConeR{"randomConeR", 0.4, "Size of random cone for estimating background fluctuations"}, + minDeltaRToJet{"minDeltaRToJet", 0.0, + "Min dR between random cone axis and lead./sublead. jet axis; if 0 -> use R_jet + R_rc"}; + } bkgd; + + + // ---------- Normalization FT0 by means ---------- + struct FT0A : ConfigurableGroup + { + std::string prefix = "ft0a"; + Configurable mean{"mean", -1., "Mean FT0A signal"}, + meanPartLevel{"meanPartLevel", -1., "Mean Nch (part level) within FT0A acceptance"}, + meanZeq{"meanZeq", -1., "Mean equalized FT0A signal"}; + } ft0a; + + struct FT0C : ConfigurableGroup + { + std::string prefix = "ft0c"; + Configurable mean{"mean", -1., "Mean FT0C signal"}, + meanPartLevel{"meanPartLevel", -1., "Mean Nch (part level) within FT0C acceptance"}, + meanZeq{"meanZeq", -1., "Mean equalized FT0C signal"}; + } ft0c; - Configurable trkEtaCut{"trkEtaCut", 0.9, "Eta acceptance of TPC"}; - Configurable jetR{"jetR", 0.4, "Jet cone radius"}; - Configurable maxJetConstituentPt{"maxJetConstituentPt", 100., "Remove jets with constituent above this pT cut"}; - Configurable randomConeR{"randomConeR", 0.4, "Size of random cone for estimating background fluctuations"}; - Configurable randomConeJetDeltaR{"randomConeJetDeltaR", 0.0, "Min distance between high pT jet axis and random cone axis; if default, min distance is set to R_Jet + R_RC "}; + // ---------- TT / recoil ---------- + struct TT : ConfigurableGroup + { + std::string prefix = "triggerTrack"; + Configurable fracSig{"fracSig", 0.9, "Fraction of events used for signal TT"}; + Configurable recoilRegion{"recoilRegion", 0.6, "Width of recoil acceptance"}; - Configurable triggerMasks{"triggerMasks", "", "Relevant trigger masks: fTrackLowPt,fTrackHighPt"}; - Configurable skipMBGapEvents{"skipMBGapEvents", false, - "flag to choose to reject min. bias gap events; jet-level rejection " - "applied at the jet finder level, here rejection is applied for " - "collision and track process functions"}; + Configurable> refPtRange{"refPtRange", {5., 7}, "Reference TT pT range [min,max] (GeV/c)"}, + sigPtRange{"sigPtRange", {20., 50}, "Signal TT pT range [min,max] (GeV/c)"}; - Configurable applyRCTSelections{"applyRCTSelections", true, "decide to apply RCT selections"}; - Configurable rctLabel{"rctLabel", "CBT_hadronPID", "apply rct flag"}; // CBT - Configurable rejectLimitedAcceptanceRct{"rejectLimitedAcceptanceRct", false, "reject data with flag LimitedAcceptance or MC reproducable"}; - Configurable requireZDCRct{"requireZDCRct", false, "is ZDC flag needed?"}; + Configurable> phiRestr{"phiRestr", {0., 6.3}, "Phi restriction [min,max] (rad) for TT search"}; + } tt; - Configurable meanFT0A{"meanFT0A", -1., "Mean value of FT0A signal"}; - Configurable meanFT0C{"meanFT0C", -1., "Mean value of FT0C signal"}; - Configurable meanZeqFT0A{"meanZeqFT0A", -1., "Mean value of equalized FT0A signal"}; - Configurable meanZeqFT0C{"meanZeqFT0C", -1., "Mean value of equalized FT0C signal"}; + // ---------- Two particle correlations ---------- + struct TwoPartCorrel : ConfigurableGroup + { + std::string prefix = "twoPartCorrel"; + Configurable> leadPtRange{"leadPtRange", {4., 6.}, "Leading track pT range [min,max] (GeV/c)"}; + Configurable associatTrackPtMin{"associatTrackPtMin", 2., "Associated track minimum pT (GeV/c)"}; + } twoPartCorrel; - Configurable meanFT0APartLevel{"meanFT0APartLevel", -1., "Mean number of charged part. within FT0A acceptance"}; - Configurable meanFT0CPartLevel{"meanFT0CPartLevel", -1., "Mean number of charged part. within FT0C acceptance"}; - // Parameters for recoil jet selection - Configurable> ptTTref{"ptTTref", {5., 7}, "Transverse momentum (min, max) range for reference TT"}; - Configurable> ptTTsig{"ptTTsig", {20., 50}, "Transverse momentum (min, max) range for signal TT"}; - Configurable recoilRegion{"recoilRegion", 0.6, "Width of recoil acceptance"}; - Configurable> phiRestrTTSelection{"phiRestrTTSelection", {0., 6.3}, "Restriction on phi angle (min, max) to search for TT"}; + // ---------- Histogram settings ---------- + struct Hist : ConfigurableGroup + { + std::string prefix = "hist"; + Configurable sumw2{"sumw2", false, "Enable Sumw2() for histograms"}; - // Leading track and associated track - Configurable> pTLeadTrack{"pTLeadTrack", {4., 6.}, "Transverse momenturm range (min, max) for leading tracks"}; - Configurable pTAssociatTrackMin{"pTAssociatTrackMin", 2., "Min transverse momenturm for associated tracks"}; + Configurable jetPtMax{"jetPtMax", 100, "Maximum jet pT stored"}, + multNBins{"multNBins", 600, "Number of bins for scaled FT0M multiplicity"}, + zdcTimeNBins{"zdcTimeNBins", 240, "Number of bins for ZDC timing histograms"}; - // List of configurable parameters for histograms - Configurable histJetPt{"histJetPt", 100, "Maximum value of jet pT stored in histograms"}; - Configurable histMultBins{"histMultBins", 600, "Number of bins for scaled FT0M multiplicity"}; - Configurable histZDCTimeBins{"histZDCTimeBins", 240, "Number of bins for ZDC timing histograms"}; + ConfigurableAxis multFT0CThresh{"multFT0CThresh", {VARIABLE_WIDTH, 0.0, 0.133, 0.233, 0.367, 0.567, 0.767, 1.067, 1.4, 1.867, 2.5, 3.9, 5.4, 6.9, 20.}, "Percentiles of scaled FT0C: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // default values for raw data + ConfigurableAxis multFT0CThreshPartLevel{"multFT0CThreshPartLevel", {VARIABLE_WIDTH, 0.0, 0.133, 0.233, 0.367, 0.567, 0.767, 1.067, 1.4, 1.867, 2.5, 3.9, 5.4, 6.9, 20.}, "Percentiles of scaled FT0C: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; - // Axes specification - ConfigurableAxis multFT0CThresh{"multFT0CThresh", {VARIABLE_WIDTH, 0.0, 0.133, 0.233, 0.367, 0.567, 0.767, 1.067, 1.4, 1.867, 2.5, 3.9, 5.4, 6.9, 20.}, "Percentiles of scaled FT0C: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // default values for raw data - ConfigurableAxis multFT0MThresh{"multFT0MThresh", {VARIABLE_WIDTH, 0.0, 0.167, 0.267, 0.4, 0.567, 0.8, 1.067, 1.4, 1.833, 2.433, 3.667, 5.1, 6.433, 20.}, "Percentiles of scaled FT0M: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // default values for raw data + ConfigurableAxis multFT0MThresh{"multFT0MThresh", {VARIABLE_WIDTH, 0.0, 0.167, 0.267, 0.4, 0.567, 0.8, 1.067, 1.4, 1.833, 2.433, 3.667, 5.1, 6.433, 20.}, "Percentiles of scaled FT0M: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // default values for raw data + ConfigurableAxis multFT0MThreshPartLevel{"multFT0MThreshPartLevel", {VARIABLE_WIDTH, 0.0, 0.167, 0.267, 0.4, 0.567, 0.8, 1.067, 1.4, 1.833, 2.433, 3.667, 5.1, 6.433, 20.}, "Percentiles of scaled FT0M: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; + } hist; - ConfigurableAxis multFT0CThreshPartLevel{"multFT0CThreshPartLevel", {VARIABLE_WIDTH, 0.0, 0.133, 0.233, 0.367, 0.567, 0.767, 1.067, 1.4, 1.867, 2.5, 3.9, 5.4, 6.9, 20.}, "Percentiles of scaled FT0C: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; - ConfigurableAxis multFT0MThreshPartLevel{"multFT0MThreshPartLevel", {VARIABLE_WIDTH, 0.0, 0.167, 0.267, 0.4, 0.567, 0.8, 1.067, 1.4, 1.833, 2.433, 3.667, 5.1, 6.433, 20.}, "Percentiles of scaled FT0M: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // Auxiliary variables std::unique_ptr randGen = std::make_unique(0); // Declare filter on collision Z vertex - Filter jCollisionFilter = nabs(aod::jcollision::posZ) < vertexZCut.node(); - Filter jCollisionFilterMC = nabs(aod::jmccollision::posZ) < vertexZCut.node(); - Filter collisionFilter = nabs(aod::collision::posZ) < vertexZCut.node(); + Filter jCollisionFilter = nabs(aod::jcollision::posZ) < ev.vertexZCut.node(); + Filter jCollisionFilterMC = nabs(aod::jmccollision::posZ) < ev.vertexZCut.node(); + Filter collisionFilter = nabs(aod::collision::posZ) < ev.vertexZCut.node(); // Declare filters on accepted tracks and MC particles (settings for jet reco are provided in the jet finder wagon) - Filter trackFilter = aod::jtrack::pt > trkPtMin.node() && aod::jtrack::pt < trkPtMax.node() && nabs(aod::jtrack::eta) < trkEtaCut.node(); - Filter partFilter = nabs(aod::jmcparticle::eta) < trkEtaCut.node(); + Filter trackFilter = aod::jtrack::pt > trk.ptMin.node() && aod::jtrack::pt < trk.ptMax.node() && nabs(aod::jtrack::eta) < trk.etaCut.node(); + Filter partFilter = nabs(aod::jmcparticle::eta) < trk.etaCut.node(); // Declare filter on jets - Filter jetRadiusFilter = aod::jet::r == nround(jetR.node() * 100.); - Filter jetEtaFilter = nabs(aod::jet::eta) < trkEtaCut.node() - jetR.node(); // 0.5 in our analysis + Filter jetRadiusFilter = aod::jet::r == nround(jet.radius.node() * 100.); + Filter jetEtaFilter = nabs(aod::jet::eta) < trk.etaCut.node() - jet.radius.node(); // 0.5 in our analysis HistogramRegistry spectra; @@ -189,12 +251,12 @@ struct RecoilJets { void init(InitContext const&) { // Initialize histogram axes: configurable - AxisSpec pT{histJetPt, 0.0, histJetPt * 1., "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec jetPTcorr{histJetPt + 20, -20., histJetPt * 1.0, "#it{p}_{T, jet}^{ch, corr} (GeV/#it{c})"}; - AxisSpec scaledFT0A{histMultBins, 0.0, 20., "FT0A / #LT FT0A #GT"}; - AxisSpec scaledFT0C{histMultBins, 0.0, 20., "FT0C / #LT FT0C #GT"}; - AxisSpec scaledFT0M{histMultBins, 0.0, 20., "FT0M^{*}"}; - AxisSpec zdcTiming{histZDCTimeBins, -30., 30., ""}; + AxisSpec pT{hist.jetPtMax, 0.0, hist.jetPtMax * 1., "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec jetPTcorr{hist.jetPtMax + 20, -20., hist.jetPtMax * 1.0, "#it{p}_{T, jet}^{ch, corr} (GeV/#it{c})"}; + AxisSpec scaledFT0A{hist.multNBins, 0.0, 20., "FT0A / #LT FT0A #GT"}; + AxisSpec scaledFT0C{hist.multNBins, 0.0, 20., "FT0C / #LT FT0C #GT"}; + AxisSpec scaledFT0M{hist.multNBins, 0.0, 20., "FT0M^{*}"}; + AxisSpec zdcTiming{hist.zdcTimeNBins, -30., 30., ""}; // Fixed size histo AxisSpec unscaledFT0A{2000, 0.0, 40000., "FT0A"}; @@ -226,11 +288,11 @@ struct RecoilJets { {"FT0C", unscaledFT0C}, {"FT0M", unscaledFT0M}}}; - std::array, 2> arrConfigurableAxis = {{{"FT0C", multFT0CThresh, nameFT0Caxis}, - {"FT0M", multFT0MThresh, nameFT0Maxis}}}; + std::array, 2> arrConfigurableAxis = {{{"FT0C", hist.multFT0CThresh, nameFT0Caxis}, + {"FT0M", hist.multFT0MThresh, nameFT0Maxis}}}; - std::array, 2> arrConfigurableAxisPartLevel = {{{"FT0C", multFT0CThreshPartLevel, nameFT0Caxis}, - {"FT0M", multFT0MThreshPartLevel, nameFT0Maxis}}}; + std::array, 2> arrConfigurableAxisPartLevel = {{{"FT0C", hist.multFT0CThreshPartLevel, nameFT0Caxis}, + {"FT0M", hist.multFT0MThreshPartLevel, nameFT0Maxis}}}; // Zero-degree calorimeter std::array, 3> arrAxisSpecZDCNeutron = {{{"ZNA", zdcNeutronA}, @@ -242,15 +304,15 @@ struct RecoilJets { {"ZPM", zdcProtonM}}}; // Convert configurable strings to std::string - std::string evSelToString = static_cast(evSel); - std::string trkSelToString = static_cast(trkSel); + std::string evSelToString = static_cast(ev.sel); + std::string trkSelToString = static_cast(trk.sel); eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(evSelToString); trackSelection = jetderiveddatautilities::initialiseTrackSelection(trkSelToString); - triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); + triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(ev.triggerMasks); - const auto phiMin = phiRestrTTSelection->at(0); - const auto phiMax = phiRestrTTSelection->at(1); + const auto phiMin = tt.phiRestr->at(0); + const auto phiMax = tt.phiRestr->at(1); // List of raw and MC det. distributions if (doprocessData || doprocessMCDetLevel || doprocessMCDetLevelWeighted) { @@ -267,18 +329,18 @@ struct RecoilJets { spectra.add("hTTSig_pT", "pT spectrum of all found TT_{Sig} cand.", kTH1F, {{40, 10., 50.}}); // needed to distinguish merged data from diff. wagons - spectra.add("hJetPtEtaPhiRhoArea", "Charact. of inclusive jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}, setSumw2); - spectra.add("hJetArea_JetPt_Rho_TTRef", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, setSumw2); - spectra.add("hJetArea_JetPt_Rho_TTSig", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, setSumw2); + spectra.add("hJetPtEtaPhiRhoArea", "Charact. of inclusive jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}, hist.sumw2); + spectra.add("hJetArea_JetPt_Rho_TTRef", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, hist.sumw2); + spectra.add("hJetArea_JetPt_Rho_TTSig", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, hist.sumw2); for (const auto& eaAxis : arrConfigurableAxis) { spectra.add(Form("hScaled%s_vertexZ", eaAxis.label), "Z vertex of collisions", - kTH2F, {{eaAxis.axis, eaAxis.axisName}, {60, -12., 12., "#it{z}_{vertex}"}}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {60, -12., 12., "#it{z}_{vertex}"}}, hist.sumw2); spectra.add(Form("hScaled%sTrackPtEtaPhi", eaAxis.label), "Charact. of tracks", - kTHnSparseF, {{eaAxis.axis, eaAxis.axisName}, pT, pseudorap, phiAngle}, setSumw2); + kTHnSparseF, {{eaAxis.axis, eaAxis.axisName}, pT, pseudorap, phiAngle}, hist.sumw2); auto tmpHistPointer = spectra.add(Form("hScaled%s_Ntrig", eaAxis.label), Form("Total number of selected triggers per class vs scaled %s", eaAxis.label), @@ -296,55 +358,55 @@ struct RecoilJets { spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTRef", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTSig", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_TTRef", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_TTSig", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_Corr_TTRef", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_Corr_TTSig", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_TTRef", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_TTSig", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, hist.sumw2); spectra.add(Form("hScaled%s_Rho", eaAxis.label), Form("Scaled %s & #rho", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, hist.sumw2); spectra.add(Form("hScaled%s_Rho_TTRef", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #rho", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, hist.sumw2); spectra.add(Form("hScaled%s_Rho_TTSig", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #rho", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTRef_RectrictedPhi", eaAxis.label), Form("Events w. TT_{Ref} #in #varphi (%.2f, %.2f): scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiMin, phiMax, eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTSig_RectrictedPhi", eaAxis.label), Form("Events w. TT_{Sig} #in #varphi (%.2f, %.2f): scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiMin, phiMax, eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); } for (const auto& eaAxis : arrAxisSpecScaledEA) { @@ -369,14 +431,14 @@ struct RecoilJets { spectra.add("ptHat", "Distribution of pT hat", kTH1F, {{2000, 0.0, 1000.}}); - spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}, setSumw2); - spectra.add("hJetArea_JetPt_Rho_TTRef_Part", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, setSumw2); - spectra.add("hJetArea_JetPt_Rho_TTSig_Part", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, setSumw2); + spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}, hist.sumw2); + spectra.add("hJetArea_JetPt_Rho_TTRef_Part", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, hist.sumw2); + spectra.add("hJetArea_JetPt_Rho_TTSig_Part", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}, hist.sumw2); for (const auto& eaAxis : arrConfigurableAxisPartLevel) { spectra.add(Form("hScaled%s_vertexZMC", eaAxis.label), "Z vertex of MC collision", - kTH2F, {{eaAxis.axis, eaAxis.axisName}, {60, -12., 12., "#it{z}_{vertex}"}}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {60, -12., 12., "#it{z}_{vertex}"}}, hist.sumw2); auto tmpHistPointer = spectra.add(Form("hScaled%s_Ntrig_Part", eaAxis.label), Form("Total number of selected triggers per class vs scaled %s", eaAxis.label), @@ -386,7 +448,7 @@ struct RecoilJets { spectra.add(Form("hScaled%sPartPtEtaPhi", eaAxis.label), "Charact. of particles", - kTHnSparseF, {{eaAxis.axis, eaAxis.axisName}, pT, pseudorap, phiAngle}, setSumw2); + kTHnSparseF, {{eaAxis.axis, eaAxis.axisName}, pT, pseudorap, phiAngle}, hist.sumw2); spectra.add(Form("hScaled%s_TTRef_per_event_Part", eaAxis.label), Form("Number of TT_{Ref} per event vs scaled %s", eaAxis.label), @@ -398,56 +460,56 @@ struct RecoilJets { spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTRef_Part", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTSig_Part", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_TTRef_Part", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_TTSig_Part", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, pT}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_Corr_TTRef_Part", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_Corr_TTSig_Part", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_TTRef_Part", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, hist.sumw2); spectra.add(Form("hScaled%s_Recoil_JetPt_TTSig_Part", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #it{p}_{T} of recoil jets", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, pT}, hist.sumw2); spectra.add(Form("hScaled%s_Rho_Part", eaAxis.label), Form("Scaled %s & #rho", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, hist.sumw2); spectra.add(Form("hScaled%s_Rho_TTRef_Part", eaAxis.label), Form("Events w. TT_{Ref}: scaled %s & #rho", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, hist.sumw2); spectra.add(Form("hScaled%s_Rho_TTSig_Part", eaAxis.label), Form("Events w. TT_{Sig}: scaled %s & #rho", eaAxis.label), - kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, setSumw2); + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}, hist.sumw2); // Rectricted phi range for TT selection spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTRef_RectrictedPhi_Part", eaAxis.label), Form("Events w. TT_{Ref} #in #varphi (%.2f, %.2f): scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiMin, phiMax, eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); spectra.add(Form("hScaled%s_DPhi_JetPt_Corr_TTSig_RectrictedPhi_Part", eaAxis.label), Form("Events w. TT_{Sig} #in #varphi (%.2f, %.2f): scaled %s & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiMin, phiMax, eaAxis.label), - kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, setSumw2); + kTH3F, {{eaAxis.axis, eaAxis.axisName}, deltaPhiAngle, jetPTcorr}, hist.sumw2); } for (const auto& eaAxis : arrAxisSpecScaledEA) { @@ -476,126 +538,126 @@ struct RecoilJets { // Part. level jets spectra.add("hPartLevelInclusiveJetsPt", "All part. level inclusive jets", - kTH1F, {partJetPt}, setSumw2); + kTH1F, {partJetPt}, hist.sumw2); spectra.add("hPartLevelInclusiveJetsPtCorr", "All part. level inclusive jets", - kTH1F, {partJetPtCorr}, setSumw2); + kTH1F, {partJetPtCorr}, hist.sumw2); spectra.add("hPartLevelRecoilJetsPt", "All part. level recoil jets", - kTH1F, {partJetPt}, setSumw2); + kTH1F, {partJetPt}, hist.sumw2); spectra.add("hPartLevelRecoilJetsPtCorr", "All part. level recoil jets", - kTH1F, {partJetPtCorr}, setSumw2); + kTH1F, {partJetPtCorr}, hist.sumw2); spectra.add("hMissedInclusiveJetsPt", "Part. level inclusive jets w/o matched pair", - kTH1F, {partJetPt}, setSumw2); + kTH1F, {partJetPt}, hist.sumw2); spectra.add("hMissedInclusiveJetsPtCorr", "Part. level inclusive jets w/o matched pair", - kTH1F, {partJetPtCorr}, setSumw2); + kTH1F, {partJetPtCorr}, hist.sumw2); spectra.add("hMissedRecoilJetsPt", "Part. level recoil jets w/o matched pair", - kTH1F, {partJetPt}, setSumw2); + kTH1F, {partJetPt}, hist.sumw2); spectra.add("hMissedRecoilJetsPtCorr", "Part. level recoil jets w/o matched pair", - kTH1F, {partJetPtCorr}, setSumw2); + kTH1F, {partJetPtCorr}, hist.sumw2); //==================================================================================== // Det. level jets spectra.add("hDetLevelInclusiveJetsPt", "All reconstructed inclusive jets", - kTH1F, {detJetPt}, setSumw2); + kTH1F, {detJetPt}, hist.sumw2); spectra.add("hDetLevelInclusiveJetsPtCorr", "All reconstructed inclusive jets", - kTH1F, {detJetPtCorr}, setSumw2); + kTH1F, {detJetPtCorr}, hist.sumw2); spectra.add("hDetLevelRecoilJetsPt", "All reconstructed recoil jets", - kTH1F, {detJetPt}, setSumw2); + kTH1F, {detJetPt}, hist.sumw2); spectra.add("hDetLevelRecoilJetsPtCorr", "All reconstructed recoil jets", - kTH1F, {detJetPtCorr}, setSumw2); + kTH1F, {detJetPtCorr}, hist.sumw2); spectra.add("hFakeInclusiveJetsPt", "Det. level inclusive jets w/o matched pair", - kTH1F, {detJetPt}, setSumw2); + kTH1F, {detJetPt}, hist.sumw2); spectra.add("hFakeInclusiveJetsPtCorr", "Det. level inclusive jets w/o matched pair", - kTH1F, {detJetPtCorr}, setSumw2); + kTH1F, {detJetPtCorr}, hist.sumw2); spectra.add("hFakeRecoilJetsPt", "Det. level recoil jets w/o matched pair", - kTH1F, {detJetPt}, setSumw2); + kTH1F, {detJetPt}, hist.sumw2); spectra.add("hFakeRecoilJetsPtCorr", "Det. level recoil jets w/o matched pair", - kTH1F, {detJetPtCorr}, setSumw2); + kTH1F, {detJetPtCorr}, hist.sumw2); //==================================================================================== // Response matices with inclusive jets spectra.add("hResponseMatrixInclusiveJetsPt", "Correlation inclusive #it{p}_{T, det.} vs. #it{p}_{T, part}", - kTH2F, {detJetPt, partJetPt}, setSumw2); + kTH2F, {detJetPt, partJetPt}, hist.sumw2); spectra.add("hResponseMatrixInclusiveJetsPtCorr", "Correlation inclusive #it{p}_{T, det.} vs. #it{p}_{T, part}", - kTH2F, {detJetPtCorr, partJetPtCorr}, setSumw2); + kTH2F, {detJetPtCorr, partJetPtCorr}, hist.sumw2); //==================================================================================== // Response matices with recoil jets spectra.add("hResponseMatrixRecoilJetsPt", "Correlation recoil #it{p}_{T, det.} vs. #it{p}_{T, part}", - kTH2F, {detJetPt, partJetPt}, setSumw2); + kTH2F, {detJetPt, partJetPt}, hist.sumw2); spectra.add("hResponseMatrixRecoilJetsPtCorr", "Correlation recoil #it{p}_{T, det.} vs. #it{p}_{T, part}", - kTH2F, {detJetPtCorr, partJetPtCorr}, setSumw2); + kTH2F, {detJetPtCorr, partJetPtCorr}, hist.sumw2); //==================================================================================== // Jet energy scale and resolution: pT and phi spectra.add("hInclusiveJESPt", "ES of inclusive jets vs. #it{p}_{T, part}", - kTH2F, {relJetSmearPt, partJetPt}, setSumw2); + kTH2F, {relJetSmearPt, partJetPt}, hist.sumw2); spectra.add("hInclusiveJESPtCorr", "ES of inclusive jets vs. #it{p}_{T, part}", - kTH2F, {relJetSmearPt, partJetPtCorr}, setSumw2); + kTH2F, {relJetSmearPt, partJetPtCorr}, hist.sumw2); spectra.add("hRecoilJESPt", "ES of recoil jets vs. #it{p}_{T, part}", - kTH2F, {relJetSmearPt, partJetPt}, setSumw2); + kTH2F, {relJetSmearPt, partJetPt}, hist.sumw2); spectra.add("hRecoilJESPtCorr", "ES of recoil jets vs. #it{p}_{T, part}", - kTH2F, {relJetSmearPt, partJetPtCorr}, setSumw2); + kTH2F, {relJetSmearPt, partJetPtCorr}, hist.sumw2); - AxisSpec jetSmearPhi{40, -1., 1., "#it{#varphi}_{part} - #it{#varphi}_{det}"}; + AxisSpec jetSmearPhi{100, -0.5, 0.5, "#it{#varphi}_{part} - #it{#varphi}_{det}"}; spectra.add("hInclusiveJESPhi", "#varphi resolution as a func. of jet #it{p}_{T, part}", - kTH2F, {jetSmearPhi, partJetPt}, setSumw2); + kTH2F, {jetSmearPhi, partJetPt}, hist.sumw2); spectra.add("hRecoilJESPhi", "#varphi resolution as a func. of jet #it{p}_{T, part}", - kTH2F, {jetSmearPhi, partJetPt}, setSumw2); + kTH2F, {jetSmearPhi, partJetPt}, hist.sumw2); //==================================================================================== @@ -604,13 +666,13 @@ struct RecoilJets { "# of det. level inclusive jets per 1 part. level jet vs. #it{p}_{T, det.} vs. #it{p}_{T, part.}", kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, {200, 0.0, 200., "#it{p}_{T, det.}"}, - {200, 0.0, 200., "#it{p}_{T, part.}"}}, setSumw2); + {200, 0.0, 200., "#it{p}_{T, part.}"}}, hist.sumw2); spectra.add("hNumberMatchedRecoilDetJetsPerOnePartJet", "# of det. level recoil jets per 1 part. level jet vs. #it{p}_{T, det.} vs. #it{p}_{T, part.}", kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, {200, 0.0, 200., "#it{p}_{T, det.}"}, - {200, 0.0, 200., "#it{p}_{T, part.}"}}, setSumw2); + {200, 0.0, 200., "#it{p}_{T, part.}"}}, hist.sumw2); } // Multiplicity for raw data and detector level MC @@ -621,14 +683,14 @@ struct RecoilJets { for (const auto& eaAxis : arrAxisSpecUnscaledEA) { spectra.add(Form("hMult%s", eaAxis.label), Form("Mult. signal %s", eaAxis.label), - kTH1F, {eaAxis.axis}, setSumw2); + kTH1F, {eaAxis.axis}, hist.sumw2); } - spectra.add("hScaleMultFT0A", "Scaled FTOA signal", kTH1F, {scaledFT0A}, setSumw2); + spectra.add("hScaleMultFT0A", "Scaled FTOA signal", kTH1F, {scaledFT0A}, hist.sumw2); for (const auto& eaAxis : arrAxisSpecScaledEA) { spectra.add(Form("hScaleMult%s", eaAxis.label), Form("Scaled %s signal", eaAxis.label), - kTH1F, {eaAxis.axis}, setSumw2); + kTH1F, {eaAxis.axis}, hist.sumw2); } //==================================================================================== @@ -636,16 +698,16 @@ struct RecoilJets { for (size_t i = 0; i < arrAxisSpecZDCNeutron.size(); ++i) { spectra.add(Form("hMult%s", arrAxisSpecZDCNeutron[i].label), Form("Mult. signal from %s", arrAxisSpecZDCNeutron[i].label), - kTH1F, {arrAxisSpecZDCNeutron[i].axis}, setSumw2); + kTH1F, {arrAxisSpecZDCNeutron[i].axis}, hist.sumw2); spectra.add(Form("hMult%s", arrAxisSpecZDCProton[i].label), Form("Mult. signal from %s", arrAxisSpecZDCProton[i].label), - kTH1F, {arrAxisSpecZDCProton[i].axis}, setSumw2); + kTH1F, {arrAxisSpecZDCProton[i].axis}, hist.sumw2); // Correlation spectra.add(Form("h%s_vs_%s", arrAxisSpecZDCProton[i].label, arrAxisSpecZDCNeutron[i].label), Form("Correlation of signals %s vs %s", arrAxisSpecZDCProton[i].label, arrAxisSpecZDCNeutron[i].label), - kTH2F, {{arrAxisSpecZDCProton[i].axis}, {arrAxisSpecZDCNeutron[i].axis}}, setSumw2); + kTH2F, {{arrAxisSpecZDCProton[i].axis}, {arrAxisSpecZDCNeutron[i].axis}}, hist.sumw2); } //==================================================================================== @@ -653,42 +715,42 @@ struct RecoilJets { for (size_t i = 0; i < arrAxisSpecUnscaledEA.size(); ++i) { spectra.add(Form("hMult%s_vs_%s", arrAxisSpecUnscaledEA[i].label, arrAxisSpecZDCNeutron[i].label), Form("Correlation of signals %s vs %s", arrAxisSpecUnscaledEA[i].label, arrAxisSpecZDCNeutron[i].label), - kTH2F, {{arrAxisSpecUnscaledEA[i].axis}, {arrAxisSpecZDCNeutron[i].axis}}, setSumw2); + kTH2F, {{arrAxisSpecUnscaledEA[i].axis}, {arrAxisSpecZDCNeutron[i].axis}}, hist.sumw2); if (i != 0) { spectra.add(Form("hScaleMult%s_vs_%s", arrAxisSpecScaledEA[i - 1].label, arrAxisSpecZDCNeutron[i].label), Form("Correlation of signals scaled %s vs %s", arrAxisSpecScaledEA[i - 1].label, arrAxisSpecZDCNeutron[i].label), - kTH2F, {{arrAxisSpecScaledEA[i - 1].axis}, {arrAxisSpecZDCNeutron[i].axis}}, setSumw2); + kTH2F, {{arrAxisSpecScaledEA[i - 1].axis}, {arrAxisSpecZDCNeutron[i].axis}}, hist.sumw2); spectra.add(Form("hScaleMult%s_vs_%s", arrAxisSpecScaledEA[i - 1].label, arrAxisSpecZDCProton[i].label), Form("Correlation of signals scaled %s vs %s", arrAxisSpecScaledEA[i - 1].label, arrAxisSpecZDCProton[i].label), - kTH2F, {{arrAxisSpecScaledEA[i - 1].axis}, {arrAxisSpecZDCProton[i].axis}}, setSumw2); + kTH2F, {{arrAxisSpecScaledEA[i - 1].axis}, {arrAxisSpecZDCProton[i].axis}}, hist.sumw2); } else { - spectra.add("hScaleMultFT0A_vs_ZNA", "Correlation of signals scaled FT0A vs ZNA", kTH2F, {{scaledFT0A}, {arrAxisSpecZDCNeutron[i].axis}}, setSumw2); - spectra.add("hScaleMultFT0A_vs_ZPA", "Correlation of signals scaled FT0A vs ZPA", kTH2F, {{scaledFT0A}, {arrAxisSpecZDCProton[i].axis}}, setSumw2); + spectra.add("hScaleMultFT0A_vs_ZNA", "Correlation of signals scaled FT0A vs ZNA", kTH2F, {{scaledFT0A}, {arrAxisSpecZDCNeutron[i].axis}}, hist.sumw2); + spectra.add("hScaleMultFT0A_vs_ZPA", "Correlation of signals scaled FT0A vs ZPA", kTH2F, {{scaledFT0A}, {arrAxisSpecZDCProton[i].axis}}, hist.sumw2); } } spectra.add("hScaleMultFT0M_vs_ZNA_vs_ZNC", "Correlation of signals FT0M^{*} vs ZNA vs ZNC", - kTH3F, {{scaledFT0M}, {600, 0.0, 3000., "ZNA"}, {600, 0.0, 3000., "ZNC"}}, setSumw2); + kTH3F, {{scaledFT0M}, {600, 0.0, 3000., "ZNA"}, {600, 0.0, 3000., "ZNC"}}, hist.sumw2); spectra.add("hScaleMultFT0M_vs_ZPA_vs_ZPC", "Correlation of signals FT0M^{*} vs ZPA vs ZPC", - kTH3F, {{scaledFT0M}, {600, 0.0, 3000., "ZPA"}, {600, 0.0, 3000., "ZPC"}}, setSumw2); + kTH3F, {{scaledFT0M}, {600, 0.0, 3000., "ZPA"}, {600, 0.0, 3000., "ZPC"}}, hist.sumw2); } // Multiplicity for particle level MC if (doprocessEventActivityMCPartLevel || doprocessEventActivityMCPartLevelWeighted) { - spectra.add("hMultFT0APartLevel", "# of primary particles within FTOA acceptance", kTH1F, {{2000, 0.0, 1000., "FT0A"}}, setSumw2); - spectra.add("hMultFT0CPartLevel", "# of primary particles within FTOC acceptance", kTH1F, {{2000, 0.0, 1000., "FT0C"}}, setSumw2); - spectra.add("hMultFT0MPartLevel", "Total # of primary particles from FT0A & FTOC", kTH1F, {{4000, 0.0, 2000., "FT0M"}}, setSumw2); + spectra.add("hMultFT0APartLevel", "# of primary particles within FTOA acceptance", kTH1F, {{2000, 0.0, 1000., "FT0A"}}, hist.sumw2); + spectra.add("hMultFT0CPartLevel", "# of primary particles within FTOC acceptance", kTH1F, {{2000, 0.0, 1000., "FT0C"}}, hist.sumw2); + spectra.add("hMultFT0MPartLevel", "Total # of primary particles from FT0A & FTOC", kTH1F, {{4000, 0.0, 2000., "FT0M"}}, hist.sumw2); - spectra.add("hScaleMultFT0APartLevel", "Scaled # of primary particles within FTOA acceptance", kTH1F, {{scaledFT0A}}, setSumw2); + spectra.add("hScaleMultFT0APartLevel", "Scaled # of primary particles within FTOA acceptance", kTH1F, {{scaledFT0A}}, hist.sumw2); for (const auto& eaAxis : arrAxisSpecScaledEA) { spectra.add(Form("hScaleMult%sPartLevel", eaAxis.label), Form("Scaled # of primary particles within %s acceptance", eaAxis.label), - kTH1F, {{eaAxis.axis}}, setSumw2); + kTH1F, {{eaAxis.axis}}, hist.sumw2); } } @@ -704,23 +766,23 @@ struct RecoilJets { // ZNA vs. ZNC correlation spectra.add("hTimeCorrZnaZnc", "Correlat. #it{t}_{ZNA} - #it{t}_{ZNC} vs. #it{t}_{ZNA} + #it{t}_{ZNC}", - kTH2F, {{500, -10., 10., "#it{t}_{ZNA} - #it{t}_{ZNC} (ns)"}, {500, -10., 10., "#it{t}_{ZNA} + #it{t}_{ZNC} (ns)"}}, setSumw2); + kTH2F, {{500, -10., 10., "#it{t}_{ZNA} - #it{t}_{ZNC} (ns)"}, {500, -10., 10., "#it{t}_{ZNA} + #it{t}_{ZNC} (ns)"}}, hist.sumw2); for (const auto& eaAxis : arrAxisSpecScaledEA) { // ZNA vs. ZNC vs. scaled FIT signal spectra.add(Form("hTimeZnaVsZncVs%s", eaAxis.label), Form("Correlat. #it{t}_{ZNA} (ns) vs. #it{t}_{ZNC} (ns) vs. scaled %s", eaAxis.label), - kTH3F, {{zdcTiming}, {zdcTiming}, {eaAxis.axis}}, setSumw2); + kTH3F, {{zdcTiming}, {zdcTiming}, {eaAxis.axis}}, hist.sumw2); // Number of tracks from PV within acceptance |eta| < 0.8 spectra.add(Form("hScaled%s_TracksPV", eaAxis.label), Form("Correlat. scaled %s vs. PV tracks", eaAxis.label), - kTH2F, {{eaAxis.axis}, {700, 0., 700.}}, setSumw2); + kTH2F, {{eaAxis.axis}, {700, 0., 700.}}, hist.sumw2); // ITS-only tracks spectra.add(Form("hScaled%s_ITStracks", eaAxis.label), Form("Correlat. scaled %s vs. number of ITS tracks", eaAxis.label), - kTH2F, {{eaAxis.axis}, {700, 0., 700.}}, setSumw2); + kTH2F, {{eaAxis.axis}, {700, 0., 700.}}, hist.sumw2); } //==================================================================================== @@ -728,15 +790,15 @@ struct RecoilJets { for (const auto& eaAxis : arrAxisSpecUnscaledEA) { spectra.add(Form("hMultZeq%s", eaAxis.label), Form("Equalized mult. %s", eaAxis.label), - kTH1F, {{eaAxis.axis}}, setSumw2); + kTH1F, {{eaAxis.axis}}, hist.sumw2); } // Scaled EA - spectra.add("hScaledZeqFT0A", "Equalized scaled FT0A", kTH1F, {{scaledFT0A}}, setSumw2); + spectra.add("hScaledZeqFT0A", "Equalized scaled FT0A", kTH1F, {{scaledFT0A}}, hist.sumw2); for (const auto& eaAxis : arrAxisSpecScaledEA) { spectra.add(Form("hScaledZeq%s", eaAxis.label), Form("Equalized scaled %s", eaAxis.label), - kTH1F, {{eaAxis.axis}}, setSumw2); + kTH1F, {{eaAxis.axis}}, hist.sumw2); } //==================================================================================== @@ -752,13 +814,13 @@ struct RecoilJets { // Scaled FT0 signal; Run-by-run QA spectra.add("hScaledFT0APerRunPerSetOfFlags", "Scaled FT0A signal per run per set of ev. sel. flags", - kTH3F, {{scaledFT0A}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}, setSumw2); + kTH3F, {{scaledFT0A}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}, hist.sumw2); setBinLablesYZaxes(spectra.get(HIST("hScaledFT0APerRunPerSetOfFlags")), runNumbersOO, evSelFlags); for (const auto& eaAxis : arrAxisSpecScaledEA) { auto tmpHistPointer = spectra.add(Form("hScaled%sPerRunPerSetOfFlags", eaAxis.label), Form("Scaled %s signal per run per set of ev. sel. flags", eaAxis.label), - kTH3F, {{eaAxis.axis}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}, setSumw2); + kTH3F, {{eaAxis.axis}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}, hist.sumw2); setBinLablesYZaxes(tmpHistPointer, runNumbersOO, evSelFlags); } @@ -766,7 +828,7 @@ struct RecoilJets { for (const auto& eaAxis : arrAxisSpecUnscaledEA) { auto tmpHistPointer = spectra.add(Form("h%sPerRunPerSetOfFlags", eaAxis.label), Form("%s signal per run per set of ev. sel. flags", eaAxis.label), - kTH3F, {{eaAxis.axis}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}, setSumw2); + kTH3F, {{eaAxis.axis}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}, hist.sumw2); setBinLablesYZaxes(tmpHistPointer, runNumbersOO, evSelFlags); } @@ -792,45 +854,45 @@ struct RecoilJets { // Di-hadron correlation if (doprocessLeadingAndAssociatedTracksTask) { - const auto pTLeadTrackMin = pTLeadTrack->at(0); - const auto pTLeadTrackMax = pTLeadTrack->at(1); + const auto pTLeadTrackMin = twoPartCorrel.leadPtRange->at(0); + const auto pTLeadTrackMax = twoPartCorrel.leadPtRange->at(1); for (const auto& eaAxis : arrAxisSpecScaledEA) { spectra.add(Form("hScaled%s_NleadTracks", eaAxis.label), Form("Total number of selected leading tracks vs scaled %s", eaAxis.label), - kTH2F, {{eaAxis.axis}, {1, 0.0, 1.}}, setSumw2); + kTH2F, {{eaAxis.axis}, {1, 0.0, 1.}}, hist.sumw2); spectra.add(Form("hScaled%s_Correlation_LeadTrack_AssociatTracks", eaAxis.label), - Form("Leading track #it{p}_{T} #in (%.2f, %.2f); Associated track #it{p}_{T} #in (%.2f, #it{p}_{T, lead. trk})", pTLeadTrackMin, pTLeadTrackMax, pTAssociatTrackMin.value), - kTH2F, {{eaAxis.axis}, {160, -1.28, 5.0, "#it{#varphi} (rad)"}}, setSumw2); + Form("Leading track #it{p}_{T} #in (%.2f, %.2f); Associated track #it{p}_{T} #in (%.2f, #it{p}_{T, lead. trk})", pTLeadTrackMin, pTLeadTrackMax, twoPartCorrel.associatTrackPtMin.value), + kTH2F, {{eaAxis.axis}, {160, -1.28, 5.0, "#it{#varphi} (rad)"}}, hist.sumw2); } } // Bkgd fluctuations in raw and MC det. level data - const auto ptTTsigMin = ptTTsig->at(0); - const auto ptTTsigMax = ptTTsig->at(1); + const auto ptTTsigMin = tt.sigPtRange->at(0); + const auto ptTTsigMax = tt.sigPtRange->at(1); if (doprocessBkgdFluctuations || doprocessBkgdFluctuationsMCDetLevel || doprocessBkgdFluctuationsMCDetLevelWeighted) { for (const auto& eaAxis : arrAxisSpecScaledEA) { spectra.add(Form("hScaled%s_deltaPtRandomCone", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f vs. EA", randomConeR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f vs. EA", bkgd.randomConeR.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtRandomConeAvoidLeadJet", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", bkgd.randomConeR.value, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtPerpConeAvoidLeadJet", eaAxis.label), - Form("Bkgd fluctuations PC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations PC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", bkgd.randomConeR.value, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtRandomConeAvoidLeadAndSubleadJet", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead, sublead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead, sublead jet in vic. %.1f vs. EA", bkgd.randomConeR.value, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtRandomConeInEventTTSig", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f in events with TT{%.0f, %.0f} in vic. %.1f vs. EA", randomConeR.value, ptTTsigMin, ptTTsigMax, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f in events with TT{%.0f, %.0f} in vic. %.1f vs. EA", bkgd.randomConeR.value, ptTTsigMin, ptTTsigMax, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); } } @@ -838,24 +900,24 @@ struct RecoilJets { if (doprocessBkgdFluctuationsMCPartLevel || doprocessBkgdFluctuationsMCPartLevelWeighted) { for (const auto& eaAxis : arrAxisSpecScaledEA) { spectra.add(Form("hScaled%s_deltaPtRandomCone_PartLevel", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f vs. EA", randomConeR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f vs. EA", bkgd.randomConeR.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtRandomConeAvoidLeadJet_PartLevel", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", bkgd.randomConeR.value, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtPerpConeAvoidLeadJet_PartLevel", eaAxis.label), - Form("Bkgd fluctuations PC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations PC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", bkgd.randomConeR.value, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtRandomConeAvoidLeadAndSubleadJet_PartLevel", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead, sublead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead, sublead jet in vic. %.1f vs. EA", bkgd.randomConeR.value, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); spectra.add(Form("hScaled%s_deltaPtRandomConeInEventTTSig_PartLevel", eaAxis.label), - Form("Bkgd fluctuations RC with #it{R} = %.1f in events with TT{%.0f, %.0f} in vic. %.1f vs. EA", randomConeR.value, ptTTsigMin, ptTTsigMax, randomConeJetDeltaR.value), - kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, setSumw2); + Form("Bkgd fluctuations RC with #it{R} = %.1f in events with TT{%.0f, %.0f} in vic. %.1f vs. EA", bkgd.randomConeR.value, ptTTsigMin, ptTTsigMax, bkgd.minDeltaRToJet.value), + kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); } } } @@ -876,11 +938,11 @@ struct RecoilJets { double phiTT = 0.; int nTT = 0; float rho = collision.rho(); - float scaledFT0C = getScaledFT0(collision.multFT0C(), meanFT0C); - float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), meanFT0A), scaledFT0C); + float scaledFT0C = getScaledFT0(collision.multFT0C(), ft0c.mean); + float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), ft0a.mean), scaledFT0C); auto dice = randGen->Rndm(); - if (dice < fracSig) + if (dice < tt.fracSig) bSigEv = true; spectra.fill(HIST("hScaledFT0C_vertexZ"), scaledFT0C, collision.posZ(), weight); @@ -903,16 +965,16 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0MTrackPtEtaPhi"), scaledFT0M, trackPt, track.eta(), trackPhi, weight); // Search for TT candidate - const auto ptTTsigMin = ptTTsig->at(0); - const auto ptTTsigMax = ptTTsig->at(1); + const auto ptTTsigMin = tt.sigPtRange->at(0); + const auto ptTTsigMax = tt.sigPtRange->at(1); if (bSigEv && (trackPt > ptTTsigMin && trackPt < ptTTsigMax)) { vPhiOfTT.push_back(trackPhi); spectra.fill(HIST("hTTSig_pT"), trackPt, weight); ++nTT; } - const auto ptTTrefMin = ptTTref->at(0); - const auto ptTTrefMax = ptTTref->at(1); + const auto ptTTrefMin = tt.refPtRange->at(0); + const auto ptTTrefMax = tt.refPtRange->at(1); if (!bSigEv && (trackPt > ptTTrefMin && trackPt < ptTTrefMax)) { vPhiOfTT.push_back(trackPhi); ++nTT; @@ -960,8 +1022,8 @@ struct RecoilJets { spectra.fill(HIST("hJetPtEtaPhiRhoArea"), jetPt, jet.eta(), jet.phi(), rho, jetArea, weight); if (nTT > 0) { - const auto phiMin = phiRestrTTSelection->at(0); - const auto phiMax = phiRestrTTSelection->at(1); + const auto phiMin = tt.phiRestr->at(0); + const auto phiMax = tt.phiRestr->at(1); auto [dphi, bRecoilJet] = isRecoilJet(jet, phiTT); @@ -1021,11 +1083,11 @@ struct RecoilJets { double phiTT = 0.; int nTT = 0; float rho = collision.rho(); - float scaledFT0C = getScaledFT0(collision.multFT0C(), meanFT0CPartLevel); - float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), meanFT0APartLevel), scaledFT0C); + float scaledFT0C = getScaledFT0(collision.multFT0C(), ft0c.meanPartLevel); + float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), ft0a.meanPartLevel), scaledFT0C); auto dice = randGen->Rndm(); - if (dice < fracSig) + if (dice < tt.fracSig) bSigEv = true; spectra.fill(HIST("hScaledFT0C_vertexZMC"), scaledFT0C, collision.posZ(), weight); @@ -1045,15 +1107,15 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0MPartPtEtaPhi"), scaledFT0M, particlePt, particle.eta(), particlePhi, weight); // Search for TT candidate - const auto ptTTsigMin = ptTTsig->at(0); - const auto ptTTsigMax = ptTTsig->at(1); + const auto ptTTsigMin = tt.sigPtRange->at(0); + const auto ptTTsigMax = tt.sigPtRange->at(1); if (bSigEv && (particlePt > ptTTsigMin && particlePt < ptTTsigMax)) { vPhiOfTT.push_back(particlePhi); ++nTT; } - const auto ptTTrefMin = ptTTref->at(0); - const auto ptTTrefMax = ptTTref->at(1); + const auto ptTTrefMin = tt.refPtRange->at(0); + const auto ptTTrefMax = tt.refPtRange->at(1); if (!bSigEv && (particlePt > ptTTrefMin && particlePt < ptTTrefMax)) { vPhiOfTT.push_back(particlePhi); ++nTT; @@ -1097,8 +1159,8 @@ struct RecoilJets { spectra.fill(HIST("hJetPtEtaPhiRhoArea_Part"), jetPt, jet.eta(), jet.phi(), rho, jetArea, weight); if (nTT > 0) { - const auto phiMin = phiRestrTTSelection->at(0); - const auto phiMax = phiRestrTTSelection->at(1); + const auto phiMin = tt.phiRestr->at(0); + const auto phiMax = tt.phiRestr->at(1); auto [dphi, bRecoilJet] = isRecoilJet(jet, phiTT); @@ -1165,7 +1227,7 @@ struct RecoilJets { ///TODO: consider TT cand. on both MC levels simultaneously // Utilities for recoil jets; TTsis at det. level MC - std::vector vPhiOfTT = getPhiOfAllTTCandidates(tracks); + std::vector vPhiOfTT = getPhiOfAllTTsigCandidates(tracks); double phiTTSig = 0.0; bool bIsThereTTSig = vPhiOfTT.size() > 0; @@ -1298,8 +1360,8 @@ struct RecoilJets { float multFT0A = collision.multFT0A(); float multFT0C = collision.multFT0C(); float multFT0M = collision.multFT0M(); - float scaledFT0A = getScaledFT0(multFT0A, meanFT0A); - float scaledFT0C = getScaledFT0(multFT0C, meanFT0C); + float scaledFT0A = getScaledFT0(multFT0A, ft0a.mean); + float scaledFT0C = getScaledFT0(multFT0C, ft0c.mean); float scaledFT0M = getScaledFT0M(scaledFT0A, scaledFT0C); float multZNA = collision.multZNA(); @@ -1355,8 +1417,8 @@ struct RecoilJets { spectra.fill(HIST("hMultFT0CPartLevel"), collision.multFT0C(), weight); spectra.fill(HIST("hMultFT0MPartLevel"), collision.multFT0A() + collision.multFT0C(), weight); - auto scaledFT0A = getScaledFT0(collision.multFT0A(), meanFT0APartLevel); - auto scaledFT0C = getScaledFT0(collision.multFT0C(), meanFT0CPartLevel); + auto scaledFT0A = getScaledFT0(collision.multFT0A(), ft0a.meanPartLevel); + auto scaledFT0C = getScaledFT0(collision.multFT0C(), ft0c.meanPartLevel); spectra.fill(HIST("hScaleMultFT0APartLevel"), scaledFT0A, weight); spectra.fill(HIST("hScaleMultFT0CPartLevel"), scaledFT0C, weight); spectra.fill(HIST("hScaleMultFT0MPartLevel"), getScaledFT0M(scaledFT0A, scaledFT0C), weight); @@ -1378,8 +1440,8 @@ struct RecoilJets { float multFT0A = collision.multFT0A(); float multFT0C = collision.multFT0C(); float multFT0M = collision.multFT0M(); - float scaledFT0A = getScaledFT0(multFT0A, meanFT0A); - float scaledFT0C = getScaledFT0(multFT0C, meanFT0C); + float scaledFT0A = getScaledFT0(multFT0A, ft0a.mean); + float scaledFT0C = getScaledFT0(multFT0C, ft0c.mean); float scaledFT0M = getScaledFT0M(scaledFT0A, scaledFT0C); // Event with flag Sel8 @@ -1453,8 +1515,8 @@ struct RecoilJets { float multZeqFT0A = collision.multZeqFT0A(); float multZeqFT0C = collision.multZeqFT0C(); float multZeqFT0M = multZeqFT0A + multZeqFT0C; - float scaledZeqFT0A = getScaledFT0(multZeqFT0A, meanZeqFT0A); - float scaledZeqFT0C = getScaledFT0(multZeqFT0C, meanZeqFT0C); + float scaledZeqFT0A = getScaledFT0(multZeqFT0A, ft0a.meanZeq); + float scaledZeqFT0C = getScaledFT0(multZeqFT0C, ft0c.meanZeq); float scaledZeqFT0M = getScaledFT0M(scaledZeqFT0A, scaledZeqFT0C); spectra.fill(HIST("hMultZeqFT0A"), multZeqFT0A, weight); @@ -1513,8 +1575,8 @@ struct RecoilJets { std::vector vPtOfLeadingTracks; std::vector vPhiOfAssociatedTracks; - float scaledFT0C = getScaledFT0(collision.multFT0C(), meanFT0C); - float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), meanFT0A), scaledFT0C); + float scaledFT0C = getScaledFT0(collision.multFT0C(), ft0c.mean); + float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), ft0a.mean), scaledFT0C); // Search for leading tracks for (const auto& track : tracks) { @@ -1523,7 +1585,7 @@ struct RecoilJets { float trackPt = track.pt(); - if (trackPt > pTLeadTrack->at(0) && trackPt < pTLeadTrack->at(1)) { + if (trackPt > twoPartCorrel.leadPtRange->at(0) && trackPt < twoPartCorrel.leadPtRange->at(1)) { vPhiOfLeadingTracks.push_back(track.phi()); vPtOfLeadingTracks.push_back(trackPt); } @@ -1548,7 +1610,7 @@ struct RecoilJets { float trackPhi = track.phi(); // Search for associated tracks - if (trackPt > pTAssociatTrackMin && trackPt < pTLeadingTrack) { + if (trackPt > twoPartCorrel.associatTrackPtMin && trackPt < pTLeadingTrack) { double dphi = RecoDecay::constrainAngle(phiLeadingTrack - trackPhi, -1.3); spectra.fill(HIST("hScaledFT0C_Correlation_LeadTrack_AssociatTracks"), scaledFT0C, dphi, weight); spectra.fill(HIST("hScaledFT0M_Correlation_LeadTrack_AssociatTracks"), scaledFT0M, dphi, weight); @@ -1570,8 +1632,8 @@ struct RecoilJets { { //---------------------------------------------------------- float rho = collision.rho(); - float scaledFT0C = getScaledFT0(collision.multFT0C(), meanFT0C); - float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), meanFT0A), scaledFT0C); + float scaledFT0C = getScaledFT0(collision.multFT0C(), ft0c.mean); + float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), ft0a.mean), scaledFT0C); //---------------------------------------------------------- // Study bkgd fluctuations in events with TTsig @@ -1579,9 +1641,9 @@ struct RecoilJets { //---------------------------------------------------------- // Place absolutely random cone (anywhere in an event) - float randomConeEta = randGen->Uniform(-trkEtaCut + randomConeR, trkEtaCut - randomConeR); + float randomConeEta = randGen->Uniform(-trk.etaCut + bkgd.randomConeR, trk.etaCut - bkgd.randomConeR); float randomConePhi = randGen->Uniform(0.0, constants::math::TwoPI); - float radiusRC2 = std::pow(randomConeR, 2); + float radiusRC2 = std::pow(bkgd.randomConeR, 2); float areaRC = constants::math::PI * radiusRC2; float randomConePt = 0.0; @@ -1599,8 +1661,8 @@ struct RecoilJets { } // Search for TT_Sig candidate - const auto ptTTsigMin = ptTTsig->at(0); - const auto ptTTsigMax = ptTTsig->at(1); + const auto ptTTsigMin = tt.sigPtRange->at(0); + const auto ptTTsigMax = tt.sigPtRange->at(1); if (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax) { vCandForTT.emplace_back(index); } @@ -1613,7 +1675,7 @@ struct RecoilJets { // Avoid leading jet (JE jet reconstruction sorts jets by pT) // square of distance to accept RC placement in events with leading jet - float dMinR2 = std::pow(jetR + randomConeR + randomConeJetDeltaR, 2); + float dMinR2 = std::pow(jet.radius + bkgd.randomConeR + bkgd.minDeltaRToJet, 2); // max # of attempts to find a place for RC; to avoid possibility with infinite loop in While cycle const int maxAttempts = 15000; @@ -1633,7 +1695,7 @@ struct RecoilJets { break; } - randomConeEta = randGen->Uniform(-trkEtaCut + randomConeR, trkEtaCut - randomConeR); + randomConeEta = randGen->Uniform(-trk.etaCut + bkgd.randomConeR, trk.etaCut - bkgd.randomConeR); randomConePhi = randGen->Uniform(0.0, constants::math::TwoPI); dEtaLeadJet = std::pow(leadJetEta - randomConeEta, 2); @@ -1718,7 +1780,7 @@ struct RecoilJets { break; } - randomConeEta = randGen->Uniform(-trkEtaCut + randomConeR, trkEtaCut - randomConeR); + randomConeEta = randGen->Uniform(-trk.etaCut + bkgd.randomConeR, trk.etaCut - bkgd.randomConeR); randomConePhi = randGen->Uniform(0.0, constants::math::TwoPI); dEtaLeadJet = std::pow(leadJetEta - randomConeEta, 2); @@ -1761,8 +1823,8 @@ struct RecoilJets { { //---------------------------------------------------------- float rho = collision.rho(); - float scaledFT0C = getScaledFT0(collision.multFT0C(), meanFT0CPartLevel); - float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), meanFT0APartLevel), scaledFT0C); + float scaledFT0C = getScaledFT0(collision.multFT0C(), ft0c.meanPartLevel); + float scaledFT0M = getScaledFT0M(getScaledFT0(collision.multFT0A(), ft0a.meanPartLevel), scaledFT0C); //---------------------------------------------------------- // Study bkgd fluctuations in events with TTsig @@ -1770,9 +1832,9 @@ struct RecoilJets { //---------------------------------------------------------- // Place absolutely random cone (anywhere in an event) - float randomConeEta = randGen->Uniform(-trkEtaCut + randomConeR, trkEtaCut - randomConeR); + float randomConeEta = randGen->Uniform(-trk.etaCut + bkgd.randomConeR, trk.etaCut - bkgd.randomConeR); float randomConePhi = randGen->Uniform(0.0, constants::math::TwoPI); - float radiusRC2 = std::pow(randomConeR, 2); + float radiusRC2 = std::pow(bkgd.randomConeR, 2); float areaRC = constants::math::PI * radiusRC2; float randomConePt = 0.0; @@ -1790,8 +1852,8 @@ struct RecoilJets { } // Search for TT_Sig candidate - const auto ptTTsigMin = ptTTsig->at(0); - const auto ptTTsigMax = ptTTsig->at(1); + const auto ptTTsigMin = tt.sigPtRange->at(0); + const auto ptTTsigMax = tt.sigPtRange->at(1); if (particle.pt() > ptTTsigMin && particle.pt() < ptTTsigMax) { vCandForTT.emplace_back(index); } @@ -1804,7 +1866,7 @@ struct RecoilJets { // Avoid leading jet (JE jet reconstruction sorts jets by pT) // square of distance to accept RC placement in events with leading jet - float dMinR2 = std::pow(jetR + randomConeR + randomConeJetDeltaR, 2); + float dMinR2 = std::pow(jet.radius + bkgd.randomConeR + bkgd.minDeltaRToJet, 2); // max # of attempts to find a place for RC; to avoid possibility with infinite loop in While cycle const int maxAttempts = 15000; @@ -1824,7 +1886,7 @@ struct RecoilJets { break; } - randomConeEta = randGen->Uniform(-trkEtaCut + randomConeR, trkEtaCut - randomConeR); + randomConeEta = randGen->Uniform(-trk.etaCut + bkgd.randomConeR, trk.etaCut - bkgd.randomConeR); randomConePhi = randGen->Uniform(0.0, constants::math::TwoPI); dEtaLeadJet = std::pow(leadJetEta - randomConeEta, 2); @@ -1909,7 +1971,7 @@ struct RecoilJets { break; } - randomConeEta = randGen->Uniform(-trkEtaCut + randomConeR, trkEtaCut - randomConeR); + randomConeEta = randGen->Uniform(-trk.etaCut + bkgd.randomConeR, trk.etaCut - bkgd.randomConeR); randomConePhi = randGen->Uniform(0.0, constants::math::TwoPI); dEtaLeadJet = std::pow(leadJetEta - randomConeEta, 2); @@ -2243,13 +2305,13 @@ struct RecoilJets { bool skipEvent(const Collision& coll) { /// \brief: trigger cut is needed for pp data - return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits, skipMBGapEvents, applyRCTSelections, rctLabel, rejectLimitedAcceptanceRct, requireZDCRct) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); + return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits, ev.skipMBGapEvents, rct.enable, rct.label, rct.rejectLimitedAcceptance, rct.requireZDC) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); } template bool skipMCEvent(const Collision& coll) { - return !jetderiveddatautilities::selectMcCollision(coll, skipMBGapEvents, applyRCTSelections, rctLabel, rejectLimitedAcceptanceRct, requireZDCRct); + return !jetderiveddatautilities::selectMcCollision(coll, ev.skipMBGapEvents, rct.enable, rct.label, rct.rejectLimitedAcceptance, rct.requireZDC); } template @@ -2273,7 +2335,7 @@ struct RecoilJets { std::tuple isRecoilJet(const Jet& jet, double phiTT) { double dphi = std::fabs(RecoDecay::constrainAngle(jet.phi() - phiTT, -constants::math::PI)); - return {dphi, (constants::math::PI - recoilRegion) < dphi}; + return {dphi, (constants::math::PI - tt.recoilRegion) < dphi}; } double getPhiTT(const std::vector& vPhiOfTT) @@ -2293,11 +2355,11 @@ struct RecoilJets { } template - bool isJetWithHighPtConstituent(Jet const& jet) + bool isJetWithHighPtConstituent(Jet const& chJet) { bool bIsJetWithHighPtConstituent = false; - for (const auto& jetConstituent : jet.template tracks_as()) { - if (jetConstituent.pt() > maxJetConstituentPt) { + for (const auto& chJetConstituent : chJet.template tracks_as()) { + if (chJetConstituent.pt() > jet.constituentPtMax) { bIsJetWithHighPtConstituent = true; break; } @@ -2337,7 +2399,7 @@ struct RecoilJets { } template - std::vector getPhiOfAllTTCandidates(JTracksTable const& tracks) + std::vector getPhiOfAllTTsigCandidates(JTracksTable const& tracks) { std::vector vPhiOfTT; @@ -2346,8 +2408,8 @@ struct RecoilJets { continue; // Search for TT_Sig candidate - const auto ptTTsigMin = ptTTsig->at(0); - const auto ptTTsigMax = ptTTsig->at(1); + const auto ptTTsigMin = tt.sigPtRange->at(0); + const auto ptTTsigMax = tt.sigPtRange->at(1); if (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax) { vPhiOfTT.emplace_back(track.phi()); } From 9d122e04f461e2cd67c1427c8919b4ec74eb007b Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Mon, 16 Feb 2026 01:37:07 +0100 Subject: [PATCH 4/4] [PWGJE]: Add pT matching for jets --- PWGJE/Tasks/recoilJets.cxx | 383 +++++++++++++++++++++++++------------ 1 file changed, 263 insertions(+), 120 deletions(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index 31fc8e3433d..29087baeac3 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -37,15 +37,15 @@ #include #include +#include #include #include #include #include #include #include +#include #include -#include -#include using namespace o2; using namespace o2::framework; @@ -65,28 +65,24 @@ using CollRhoPartIt = soa::Filtered>::iterator; using CollRhoOutlierPartTbl = soa::Filtered>; - // --- Event multiplicity (+ ZDC etc.) using EvMultZDCDataIt = soa::Filtered>::iterator; using EvMultOutlierZDCDetIt = soa::Filtered>::iterator; using EvMultOutlierPartIt = soa::Filtered>::iterator; - // --- Tracks / Particles -using TrackTbl = soa::Filtered; +using TrackTbl = soa::Filtered; using PartTbl = soa::Filtered; - // --- Jets (with constituents) using JetsDataTbl = soa::Filtered>; -using JetsDetTbl = soa::Filtered>; +using JetsDetTbl = soa::Filtered>; using JetsPartTbl = soa::Filtered>; // --- Matched jets (det <-> part) using MatchedJetsDetToPartTbl = soa::Filtered>; using MatchedJetsPartToDetTbl = soa::Filtered>; - // --- O2 collisions event selection (not JCollisions) using CollEvSelExtendedIt = soa::Filtered>::iterator; using BCsRun3Tbl = soa::Join; // aod::Run3MatchedToBCExclusive @@ -96,11 +92,10 @@ struct RecoilJets { // List of configurable parameters // ---------- Event selection ---------- - struct EvCfg : ConfigurableGroup - { + struct EvCfg : ConfigurableGroup { std::string prefix = "event"; Configurable sel{"sel", "sel8", "Choose event selection"}, - triggerMasks{"triggerMasks", "", "Relevant trigger masks: fTrackLowPt,fTrackHighPt"}; + triggerMasks{"triggerMasks", "", "Relevant trigger masks: fTrackLowPt,fTrackHighPt"}; Configurable vertexZCut{"vertexZCut", 10., "Accepted z-vertex range"}; Configurable skipMBGapEvents{"skipMBGapEvents", false, @@ -109,110 +104,93 @@ struct RecoilJets { "collision and track process functions"}; } ev; - // ---------- RCT / flag-based selections ---------- - struct Rct : ConfigurableGroup - { + struct Rct : ConfigurableGroup { std::string prefix = "rct"; Configurable label{"label", "CBT_hadronPID", "Apply rct flag"}; // CBT Configurable enable{"enable", true, "Apply RCT selections"}, - requireZDC{"requireZDC", false, "Require ZDC flag"}, - rejectLimitedAcceptance{"rejectLimitedAcceptance", false, "Reject LimitedAcceptance flag"}; + requireZDC{"requireZDC", false, "Require ZDC flag"}, + rejectLimitedAcceptance{"rejectLimitedAcceptance", false, "Reject LimitedAcceptance flag"}; } rct; - // ---------- Track selection ---------- - struct Trk : ConfigurableGroup - { + struct Trk : ConfigurableGroup { std::string prefix = "track"; Configurable sel{"sel", "globalTracks", "Set track selection"}; Configurable ptMin{"ptMin", 0.15, "Minimum pT of acceptanced tracks"}, - ptMax{"ptMax", 100., "Maximum pT of acceptanced tracks"}, - etaCut{"etaCut", 0.9, "Eta acceptance of TPC"}; + ptMax{"ptMax", 100., "Maximum pT of acceptanced tracks"}, + etaCut{"etaCut", 0.9, "Eta acceptance of TPC"}; } trk; - // ---------- Jet reconstruction ---------- - struct Jet : ConfigurableGroup - { + struct Jet : ConfigurableGroup { std::string prefix = "jet"; Configurable constituentPtMax{"constituentPtMax", 100., "Remove jets with constituent above this pT cut"}, - radius{"radius", 0.4, "Jet cone radius"}; + radius{"radius", 0.4, "Jet cone radius"}; } jet; - // ---------- Background tools ---------- struct Bkgd : ConfigurableGroup { std::string prefix = "bkgd"; // Random cone method Configurable randomConeR{"randomConeR", 0.4, "Size of random cone for estimating background fluctuations"}, - minDeltaRToJet{"minDeltaRToJet", 0.0, - "Min dR between random cone axis and lead./sublead. jet axis; if 0 -> use R_jet + R_rc"}; + minDeltaRToJet{"minDeltaRToJet", 0.0, + "Min dR between random cone axis and lead./sublead. jet axis; if 0 -> use R_jet + R_rc"}; } bkgd; - // ---------- Normalization FT0 by means ---------- - struct FT0A : ConfigurableGroup - { + struct FT0A : ConfigurableGroup { std::string prefix = "ft0a"; Configurable mean{"mean", -1., "Mean FT0A signal"}, - meanPartLevel{"meanPartLevel", -1., "Mean Nch (part level) within FT0A acceptance"}, - meanZeq{"meanZeq", -1., "Mean equalized FT0A signal"}; + meanPartLevel{"meanPartLevel", -1., "Mean Nch (part level) within FT0A acceptance"}, + meanZeq{"meanZeq", -1., "Mean equalized FT0A signal"}; } ft0a; - struct FT0C : ConfigurableGroup - { + struct FT0C : ConfigurableGroup { std::string prefix = "ft0c"; Configurable mean{"mean", -1., "Mean FT0C signal"}, - meanPartLevel{"meanPartLevel", -1., "Mean Nch (part level) within FT0C acceptance"}, - meanZeq{"meanZeq", -1., "Mean equalized FT0C signal"}; + meanPartLevel{"meanPartLevel", -1., "Mean Nch (part level) within FT0C acceptance"}, + meanZeq{"meanZeq", -1., "Mean equalized FT0C signal"}; } ft0c; - // ---------- TT / recoil ---------- - struct TT : ConfigurableGroup - { + struct TT : ConfigurableGroup { std::string prefix = "triggerTrack"; Configurable fracSig{"fracSig", 0.9, "Fraction of events used for signal TT"}; Configurable recoilRegion{"recoilRegion", 0.6, "Width of recoil acceptance"}; Configurable> refPtRange{"refPtRange", {5., 7}, "Reference TT pT range [min,max] (GeV/c)"}, - sigPtRange{"sigPtRange", {20., 50}, "Signal TT pT range [min,max] (GeV/c)"}; + sigPtRange{"sigPtRange", {20., 50}, "Signal TT pT range [min,max] (GeV/c)"}; Configurable> phiRestr{"phiRestr", {0., 6.3}, "Phi restriction [min,max] (rad) for TT search"}; } tt; - // ---------- Two particle correlations ---------- - struct TwoPartCorrel : ConfigurableGroup - { + struct TwoPartCorrel : ConfigurableGroup { std::string prefix = "twoPartCorrel"; Configurable> leadPtRange{"leadPtRange", {4., 6.}, "Leading track pT range [min,max] (GeV/c)"}; Configurable associatTrackPtMin{"associatTrackPtMin", 2., "Associated track minimum pT (GeV/c)"}; } twoPartCorrel; - // ---------- Histogram settings ---------- - struct Hist : ConfigurableGroup - { + struct Hist : ConfigurableGroup { std::string prefix = "hist"; Configurable sumw2{"sumw2", false, "Enable Sumw2() for histograms"}; Configurable jetPtMax{"jetPtMax", 100, "Maximum jet pT stored"}, - multNBins{"multNBins", 600, "Number of bins for scaled FT0M multiplicity"}, - zdcTimeNBins{"zdcTimeNBins", 240, "Number of bins for ZDC timing histograms"}; + multNBins{"multNBins", 600, "Number of bins for scaled FT0M multiplicity"}, + zdcTimeNBins{"zdcTimeNBins", 240, "Number of bins for ZDC timing histograms"}; - ConfigurableAxis multFT0CThresh{"multFT0CThresh", {VARIABLE_WIDTH, 0.0, 0.133, 0.233, 0.367, 0.567, 0.767, 1.067, 1.4, 1.867, 2.5, 3.9, 5.4, 6.9, 20.}, "Percentiles of scaled FT0C: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // default values for raw data + ConfigurableAxis multFT0CThresh{"multFT0CThresh", {VARIABLE_WIDTH, 0.0, 0.133, 0.233, 0.367, 0.567, 0.767, 1.067, 1.4, 1.867, 2.5, 3.9, 5.4, 6.9, 20.}, "Percentiles of scaled FT0C: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // default values for raw data ConfigurableAxis multFT0CThreshPartLevel{"multFT0CThreshPartLevel", {VARIABLE_WIDTH, 0.0, 0.133, 0.233, 0.367, 0.567, 0.767, 1.067, 1.4, 1.867, 2.5, 3.9, 5.4, 6.9, 20.}, "Percentiles of scaled FT0C: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; ConfigurableAxis multFT0MThresh{"multFT0MThresh", {VARIABLE_WIDTH, 0.0, 0.167, 0.267, 0.4, 0.567, 0.8, 1.067, 1.4, 1.833, 2.433, 3.667, 5.1, 6.433, 20.}, "Percentiles of scaled FT0M: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; // default values for raw data ConfigurableAxis multFT0MThreshPartLevel{"multFT0MThreshPartLevel", {VARIABLE_WIDTH, 0.0, 0.167, 0.267, 0.4, 0.567, 0.8, 1.067, 1.4, 1.833, 2.433, 3.667, 5.1, 6.433, 20.}, "Percentiles of scaled FT0M: 100%, 90%, 80%, 70%, 60%, 50%, 40%, 30%, 20%, 10%, 1%, 0.1%, 0.01%"}; } hist; - // Auxiliary variables std::unique_ptr randGen = std::make_unique(0); @@ -524,8 +502,7 @@ struct RecoilJets { } // Jet matching - if (doprocessJetsGeoMatching || doprocessJetsGeoMatchingWeighted) - { + if (doprocessJetsGeoMatching || doprocessJetsGeoMatchingWeighted || doprocessJetsGeoPtMatchingWeighted || doprocessJetsGeoPtMatching) { AxisSpec detJetPt{200, 0.0, 200., "#it{p}_{T, det} (GeV/#it{c})"}; AxisSpec detJetPtCorr{220, -20.0, 200., "#it{p}_{T, det}^{corr.} (GeV/#it{c})"}; @@ -544,7 +521,6 @@ struct RecoilJets { "All part. level inclusive jets", kTH1F, {partJetPtCorr}, hist.sumw2); - spectra.add("hPartLevelRecoilJetsPt", "All part. level recoil jets", kTH1F, {partJetPt}, hist.sumw2); @@ -553,7 +529,6 @@ struct RecoilJets { "All part. level recoil jets", kTH1F, {partJetPtCorr}, hist.sumw2); - spectra.add("hMissedInclusiveJetsPt", "Part. level inclusive jets w/o matched pair", kTH1F, {partJetPt}, hist.sumw2); @@ -562,7 +537,6 @@ struct RecoilJets { "Part. level inclusive jets w/o matched pair", kTH1F, {partJetPtCorr}, hist.sumw2); - spectra.add("hMissedRecoilJetsPt", "Part. level recoil jets w/o matched pair", kTH1F, {partJetPt}, hist.sumw2); @@ -581,7 +555,6 @@ struct RecoilJets { "All reconstructed inclusive jets", kTH1F, {detJetPtCorr}, hist.sumw2); - spectra.add("hDetLevelRecoilJetsPt", "All reconstructed recoil jets", kTH1F, {detJetPt}, hist.sumw2); @@ -590,7 +563,6 @@ struct RecoilJets { "All reconstructed recoil jets", kTH1F, {detJetPtCorr}, hist.sumw2); - spectra.add("hFakeInclusiveJetsPt", "Det. level inclusive jets w/o matched pair", kTH1F, {detJetPt}, hist.sumw2); @@ -599,7 +571,6 @@ struct RecoilJets { "Det. level inclusive jets w/o matched pair", kTH1F, {detJetPtCorr}, hist.sumw2); - spectra.add("hFakeRecoilJetsPt", "Det. level recoil jets w/o matched pair", kTH1F, {detJetPt}, hist.sumw2); @@ -609,7 +580,7 @@ struct RecoilJets { kTH1F, {detJetPtCorr}, hist.sumw2); //==================================================================================== - // Response matices with inclusive jets + // Response matices with inclusive jets spectra.add("hResponseMatrixInclusiveJetsPt", "Correlation inclusive #it{p}_{T, det.} vs. #it{p}_{T, part}", kTH2F, {detJetPt, partJetPt}, hist.sumw2); @@ -618,7 +589,6 @@ struct RecoilJets { "Correlation inclusive #it{p}_{T, det.} vs. #it{p}_{T, part}", kTH2F, {detJetPtCorr, partJetPtCorr}, hist.sumw2); - //==================================================================================== // Response matices with recoil jets spectra.add("hResponseMatrixRecoilJetsPt", @@ -629,7 +599,6 @@ struct RecoilJets { "Correlation recoil #it{p}_{T, det.} vs. #it{p}_{T, part}", kTH2F, {detJetPtCorr, partJetPtCorr}, hist.sumw2); - //==================================================================================== // Jet energy scale and resolution: pT and phi spectra.add("hInclusiveJESPt", @@ -640,15 +609,13 @@ struct RecoilJets { "ES of inclusive jets vs. #it{p}_{T, part}", kTH2F, {relJetSmearPt, partJetPtCorr}, hist.sumw2); - spectra.add("hRecoilJESPt", "ES of recoil jets vs. #it{p}_{T, part}", kTH2F, {relJetSmearPt, partJetPt}, hist.sumw2); - + spectra.add("hRecoilJESPtCorr", "ES of recoil jets vs. #it{p}_{T, part}", kTH2F, {relJetSmearPt, partJetPtCorr}, hist.sumw2); - AxisSpec jetSmearPhi{100, -0.5, 0.5, "#it{#varphi}_{part} - #it{#varphi}_{det}"}; spectra.add("hInclusiveJESPhi", @@ -659,20 +626,15 @@ struct RecoilJets { "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {jetSmearPhi, partJetPt}, hist.sumw2); - //==================================================================================== // Utility histograms spectra.add("hNumberMatchedInclusiveDetJetsPerOnePartJet", "# of det. level inclusive jets per 1 part. level jet vs. #it{p}_{T, det.} vs. #it{p}_{T, part.}", - kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, - {200, 0.0, 200., "#it{p}_{T, det.}"}, - {200, 0.0, 200., "#it{p}_{T, part.}"}}, hist.sumw2); + kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, {200, 0.0, 200., "#it{p}_{T, det.}"}, {200, 0.0, 200., "#it{p}_{T, part.}"}}, hist.sumw2); spectra.add("hNumberMatchedRecoilDetJetsPerOnePartJet", "# of det. level recoil jets per 1 part. level jet vs. #it{p}_{T, det.} vs. #it{p}_{T, part.}", - kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, - {200, 0.0, 200., "#it{p}_{T, det.}"}, - {200, 0.0, 200., "#it{p}_{T, part.}"}}, hist.sumw2); + kTH3F, {{6, 0.5, 6.5, "# of matched det. level jets"}, {200, 0.0, 200., "#it{p}_{T, det.}"}, {200, 0.0, 200., "#it{p}_{T, part.}"}}, hist.sumw2); } // Multiplicity for raw data and detector level MC @@ -920,6 +882,8 @@ struct RecoilJets { kTH2F, {{eaAxis.axis}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}, hist.sumw2); } } + spectra.add("hResponseLoopDet", "", kTH2F, {{100, 0., 100., "det. level"}, {100, 0., 100., "part. level"}}); + spectra.add("hResponseLoopPart", "", kTH2F, {{100, 0., 100., "det. level"}, {100, 0., 100., "part. level"}}); } //============================================================================= @@ -1217,14 +1181,14 @@ struct RecoilJets { // Construction of response matrix //============================================================================= template - void fillMatchedHistograms(JetsPart const& jetsPart, - JetsDet const& jetsDet, - JTracks const& tracks, - float partLevelCollRho, - float detLevelCollRho, - float weight = 1.) - { - ///TODO: consider TT cand. on both MC levels simultaneously + void fillMatchedGeoHistograms(JetsPart const& jetsPart, + JetsDet const& jetsDet, + JTracks const& tracks, + float partLevelCollRho, + float detLevelCollRho, + float weight = 1.) + { + /// TODO: consider TT cand. on both MC levels simultaneously // Utilities for recoil jets; TTsis at det. level MC std::vector vPhiOfTT = getPhiOfAllTTsigCandidates(tracks); @@ -1234,11 +1198,10 @@ struct RecoilJets { if (bIsThereTTSig) phiTTSig = getPhiTT(vPhiOfTT); - for (const auto& jetPart : jetsPart) - { + for (const auto& jetPart : jetsPart) { auto partJetPt = jetPart.pt(); auto partJetPtCorr = partJetPt - partLevelCollRho * jetPart.area(); - + bool bIsPartJetRecoil = get<1>(isRecoilJet(jetPart, phiTTSig)) && bIsThereTTSig; @@ -1246,29 +1209,24 @@ struct RecoilJets { spectra.fill(HIST("hPartLevelInclusiveJetsPt"), partJetPt, weight); spectra.fill(HIST("hPartLevelInclusiveJetsPtCorr"), partJetPtCorr, weight); - if (bIsPartJetRecoil) - { + if (bIsPartJetRecoil) { spectra.fill(HIST("hPartLevelRecoilJetsPt"), partJetPt, weight); spectra.fill(HIST("hPartLevelRecoilJetsPtCorr"), partJetPtCorr, weight); } - - if(jetPart.has_matchedJetGeo()) - { + + if (jetPart.has_matchedJetGeo()) { const auto& jetsDetMatched = jetPart.template matchedJetGeo_as(); - - for (const auto& jetDetMatched : jetsDetMatched) - { - // skip matches where detector level jets have a constituent with pT above specified cut - bool skipMatchedDetJet = isJetWithHighPtConstituent(jetDetMatched); - if (skipMatchedDetJet) - { + for (const auto& jetDetMatched : jetsDetMatched) { + // Skip matches where detector level jets have a constituent with pT above specified cut + const bool skipMatchedDetJet = isJetWithHighPtConstituent(jetDetMatched); + + if (skipMatchedDetJet) { // Miss jets spectra.fill(HIST("hMissedInclusiveJetsPt"), partJetPt, weight); spectra.fill(HIST("hMissedInclusiveJetsPtCorr"), partJetPtCorr, weight); - if (bIsPartJetRecoil) - { + if (bIsPartJetRecoil) { spectra.fill(HIST("hMissedRecoilJetsPt"), partJetPt, weight); spectra.fill(HIST("hMissedRecoilJetsPtCorr"), partJetPtCorr, weight); } @@ -1278,19 +1236,18 @@ struct RecoilJets { auto detJetPtCorr = detJetPt - detLevelCollRho * jetDetMatched.area(); spectra.fill(HIST("hNumberMatchedInclusiveDetJetsPerOnePartJet"), jetsDetMatched.size(), detJetPt, partJetPt, weight); - + spectra.fill(HIST("hResponseMatrixInclusiveJetsPt"), detJetPt, partJetPt, weight); spectra.fill(HIST("hResponseMatrixInclusiveJetsPtCorr"), detJetPtCorr, partJetPtCorr, weight); - + spectra.fill(HIST("hInclusiveJESPt"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); spectra.fill(HIST("hInclusiveJESPtCorr"), (partJetPtCorr - detJetPtCorr) / partJetPtCorr, partJetPtCorr, weight); spectra.fill(HIST("hInclusiveJESPhi"), jetPart.phi() - jetDetMatched.phi(), partJetPt, weight); - if (bIsPartJetRecoil) - { + if (bIsPartJetRecoil) { spectra.fill(HIST("hNumberMatchedRecoilDetJetsPerOnePartJet"), jetsDetMatched.size(), detJetPt, partJetPt, weight); - + spectra.fill(HIST("hResponseMatrixRecoilJetsPt"), detJetPt, partJetPt, weight); spectra.fill(HIST("hResponseMatrixRecoilJetsPtCorr"), detJetPtCorr, partJetPtCorr, weight); @@ -1306,17 +1263,15 @@ struct RecoilJets { spectra.fill(HIST("hMissedInclusiveJetsPt"), partJetPt, weight); spectra.fill(HIST("hMissedInclusiveJetsPtCorr"), partJetPtCorr, weight); - if (bIsPartJetRecoil) - { + if (bIsPartJetRecoil) { spectra.fill(HIST("hMissedRecoilJetsPt"), partJetPt, weight); spectra.fill(HIST("hMissedRecoilJetsPtCorr"), partJetPtCorr, weight); } - } + } } // Reconstructed jets - for (const auto& jetDet : jetsDet) - { + for (const auto& jetDet : jetsDet) { if (isJetWithHighPtConstituent(jetDet)) continue; @@ -1330,19 +1285,141 @@ struct RecoilJets { spectra.fill(HIST("hDetLevelInclusiveJetsPt"), detJetPt, weight); spectra.fill(HIST("hDetLevelInclusiveJetsPtCorr"), detJetPtCorr, weight); - if (bIsJetRecoil) - { + if (bIsJetRecoil) { spectra.fill(HIST("hDetLevelRecoilJetsPt"), detJetPt, weight); spectra.fill(HIST("hDetLevelRecoilJetsPtCorr"), detJetPtCorr, weight); } - if (!jetDet.has_matchedJetGeo()) - { + if (!jetDet.has_matchedJetGeo()) { spectra.fill(HIST("hFakeInclusiveJetsPt"), detJetPt, weight); spectra.fill(HIST("hFakeInclusiveJetsPtCorr"), detJetPtCorr, weight); - - if (bIsJetRecoil) - { + + if (bIsJetRecoil) { + spectra.fill(HIST("hFakeRecoilJetsPt"), detJetPt, weight); + spectra.fill(HIST("hFakeRecoilJetsPtCorr"), detJetPtCorr, weight); + } + } + } + } + + /// TODO: think how to implement matching matching geo/geo+pT in one function + template + void fillMatchedGeoPtHistograms(JetsPart const& jetsPart, + JetsDet const& jetsDet, + JTracks const& tracks, + float partLevelCollRho, + float detLevelCollRho, + float weight = 1.) + { + // Utilities for recoil jets; TTsis at det. level MC + std::vector vPhiOfTT = getPhiOfAllTTsigCandidates(tracks); + double phiTTSig = 0.0; + bool bIsThereTTSig = vPhiOfTT.size() > 0; + + if (bIsThereTTSig) + phiTTSig = getPhiTT(vPhiOfTT); + + for (const auto& jetPart : jetsPart) { + auto partJetPt = jetPart.pt(); + auto partJetPtCorr = partJetPt - partLevelCollRho * jetPart.area(); + + bool bIsPartJetRecoil = + get<1>(isRecoilJet(jetPart, phiTTSig)) && bIsThereTTSig; + + // Distribution of all part. level jets + spectra.fill(HIST("hPartLevelInclusiveJetsPt"), partJetPt, weight); + spectra.fill(HIST("hPartLevelInclusiveJetsPtCorr"), partJetPtCorr, weight); + + if (bIsPartJetRecoil) { + spectra.fill(HIST("hPartLevelRecoilJetsPt"), partJetPt, weight); + spectra.fill(HIST("hPartLevelRecoilJetsPtCorr"), partJetPtCorr, weight); + } + + // Geo + pT matching + if (jetPart.has_matchedJetGeo() && jetPart.has_matchedJetPt()) { + const auto& jetsDetMatched = jetPart.template matchedJetGeo_as(); + auto both = intersectMatchIds(jetPart.matchedJetGeoIds(), jetPart.matchedJetPtIds()); + + for (const auto& jetDetMatched : jetsDetMatched) { + // Skip matches where detector level jets have a constituent with pT above specified cut + const bool skipMatchedDetJet = isJetWithHighPtConstituent(jetDetMatched); + + // If indecies for geo and pT matching do not coinside, reject detector level jet + const bool skipNotBothId = !both.contains(jetDetMatched.globalIndex()); + + if (skipMatchedDetJet || skipNotBothId) { + // Miss jets + spectra.fill(HIST("hMissedInclusiveJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedInclusiveJetsPtCorr"), partJetPtCorr, weight); + + if (bIsPartJetRecoil) { + spectra.fill(HIST("hMissedRecoilJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedRecoilJetsPtCorr"), partJetPtCorr, weight); + } + } else { + auto detJetPt = jetDetMatched.pt(); + auto detJetPtCorr = detJetPt - detLevelCollRho * jetDetMatched.area(); + + spectra.fill(HIST("hNumberMatchedInclusiveDetJetsPerOnePartJet"), jetsDetMatched.size(), detJetPt, partJetPt, weight); + + spectra.fill(HIST("hResponseMatrixInclusiveJetsPt"), detJetPt, partJetPt, weight); + spectra.fill(HIST("hResponseMatrixInclusiveJetsPtCorr"), detJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hInclusiveJESPt"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hInclusiveJESPtCorr"), (partJetPtCorr - detJetPtCorr) / partJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hInclusiveJESPhi"), jetPart.phi() - jetDetMatched.phi(), partJetPt, weight); + + if (bIsPartJetRecoil) { + spectra.fill(HIST("hNumberMatchedRecoilDetJetsPerOnePartJet"), jetsDetMatched.size(), detJetPt, partJetPt, weight); + + spectra.fill(HIST("hResponseMatrixRecoilJetsPt"), detJetPt, partJetPt, weight); + spectra.fill(HIST("hResponseMatrixRecoilJetsPtCorr"), detJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hRecoilJESPt"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hRecoilJESPtCorr"), (partJetPtCorr - detJetPtCorr) / partJetPtCorr, partJetPtCorr, weight); + + spectra.fill(HIST("hRecoilJESPhi"), jetPart.phi() - jetDetMatched.phi(), partJetPt, weight); + } + } + } + } else { + // Miss jets + spectra.fill(HIST("hMissedInclusiveJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedInclusiveJetsPtCorr"), partJetPtCorr, weight); + + if (bIsPartJetRecoil) { + spectra.fill(HIST("hMissedRecoilJetsPt"), partJetPt, weight); + spectra.fill(HIST("hMissedRecoilJetsPtCorr"), partJetPtCorr, weight); + } + } + } + + // Reconstructed jets + for (const auto& jetDet : jetsDet) { + if (isJetWithHighPtConstituent(jetDet)) + continue; + + auto detJetPt = jetDet.pt(); + auto detJetPtCorr = detJetPt - detLevelCollRho * jetDet.area(); + + bool bIsJetRecoil = + get<1>(isRecoilJet(jetDet, phiTTSig)) && bIsThereTTSig; + + // Distribution of all det. level jets + spectra.fill(HIST("hDetLevelInclusiveJetsPt"), detJetPt, weight); + spectra.fill(HIST("hDetLevelInclusiveJetsPtCorr"), detJetPtCorr, weight); + + if (bIsJetRecoil) { + spectra.fill(HIST("hDetLevelRecoilJetsPt"), detJetPt, weight); + spectra.fill(HIST("hDetLevelRecoilJetsPtCorr"), detJetPtCorr, weight); + } + + if (!jetDet.has_matchedJetGeo()) { + spectra.fill(HIST("hFakeInclusiveJetsPt"), detJetPt, weight); + spectra.fill(HIST("hFakeInclusiveJetsPtCorr"), detJetPtCorr, weight); + + if (bIsJetRecoil) { spectra.fill(HIST("hFakeRecoilJetsPt"), detJetPt, weight); spectra.fill(HIST("hFakeRecoilJetsPtCorr"), detJetPtCorr, weight); } @@ -2131,12 +2208,34 @@ struct RecoilJets { auto partLevelCollRho = mcCollisions.iteratorAt(mcCollisionId).rho(); // Slice for mc part level jets associated to a given mcCollisionId - auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) + auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) - fillMatchedHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho); + fillMatchedGeoHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho); } PROCESS_SWITCH(RecoilJets, processJetsGeoMatching, "process matching of MC jets using Geo criterion (no weight; MB events)", false); + //___________________________ + void processJetsGeoPtMatching(CollRhoDetIt const& collision, + CollRhoPartTbl const& mcCollisions, + TrackTbl const& tracksPerColl, + MatchedJetsDetToPartTbl const& mcDetJetsPerColl, + MatchedJetsPartToDetTbl const& mcPartJets) + { + // Skip detector level collisions + if (skipEvent(collision) || !collision.has_mcCollision()) + return; + + auto mcCollisionId = collision.mcCollisionId(); + auto detLevelCollRho = collision.rho(); + auto partLevelCollRho = mcCollisions.iteratorAt(mcCollisionId).rho(); + + // Slice for mc part level jets associated to a given mcCollisionId + auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) + + fillMatchedGeoPtHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho); + } + PROCESS_SWITCH(RecoilJets, processJetsGeoPtMatching, "process matching of MC jets using Geo+Pt criteria (no weight; MB events)", false); + //_________________________________ void processJetsGeoMatchingWeighted(CollRhoOutlierDetIt const& collision, CollRhoOutlierPartTbl const& mcCollisions, @@ -2154,12 +2253,35 @@ struct RecoilJets { auto weight = mcCollisions.iteratorAt(mcCollisionId).weight(); // Slice for mc part level jets associated to a given mcCollisionId - auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) + auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) - fillMatchedHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho, weight); + fillMatchedGeoHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho, weight); } PROCESS_SWITCH(RecoilJets, processJetsGeoMatchingWeighted, "process matching of MC jets using Geo criterion (weighted JJ)", false); + //___________________________________ + void processJetsGeoPtMatchingWeighted(CollRhoOutlierDetIt const& collision, + CollRhoOutlierPartTbl const& mcCollisions, + TrackTbl const& tracksPerColl, + MatchedJetsDetToPartTbl const& mcDetJetsPerColl, + MatchedJetsPartToDetTbl const& mcPartJets) + { + // Skip detector level collisions + if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) + return; + + auto mcCollisionId = collision.mcCollisionId(); + auto detLevelCollRho = collision.rho(); + auto partLevelCollRho = mcCollisions.iteratorAt(mcCollisionId).rho(); + auto weight = mcCollisions.iteratorAt(mcCollisionId).weight(); + + // Slice for mc part level jets associated to a given mcCollisionId + auto mcPartJetsPerMcCollision = mcPartJets.sliceBy(partJetsPerMcCollision, mcCollisionId); // signature: (__column to slice___, __index__) + + fillMatchedGeoPtHistograms(mcPartJetsPerMcCollision, mcDetJetsPerColl, tracksPerColl, partLevelCollRho, detLevelCollRho, weight); + } + PROCESS_SWITCH(RecoilJets, processJetsGeoPtMatchingWeighted, "process matching of MC jets using Geo+Pt criteria (weighted JJ)", false); + //============================================================================= // Event Activity analysis in OO collisions (raw and MC detector level (no weight; MB events)) //============================================================================= @@ -2397,8 +2519,8 @@ struct RecoilJets { return binNumber; } - - template + + template std::vector getPhiOfAllTTsigCandidates(JTracksTable const& tracks) { std::vector vPhiOfTT; @@ -2437,6 +2559,27 @@ struct RecoilJets { histPointer->GetZaxis()->SetBinLabel(iFlag + 1, zAxis[iFlag]); } } + + template + std::unordered_set intersectMatchIds(MassiveA const& geoIds, MassiveB const& ptIds) + { + std::unordered_set geoSet; + geoSet.reserve(geoIds.size()); + for (const auto& id : geoIds) { + if (id >= 0) { + geoSet.insert(id); + } + } + + std::unordered_set bothSet; + bothSet.reserve(std::min(geoIds.size(), ptIds.size())); + for (const auto& id : ptIds) { + if (id >= 0 && geoSet.contains(id)) { + bothSet.insert(id); + } + } + return bothSet; + } }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)