From fc781097015a7b04e15e1d953cc9d6f52fd3b7b6 Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Thu, 15 Jan 2026 15:21:57 +0100 Subject: [PATCH 1/4] [PWGJE] Code refactoring --- PWGJE/Tasks/recoilJets.cxx | 1128 +++++++++++++++++++++++------------- 1 file changed, 730 insertions(+), 398 deletions(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index 2428d4c2dd4..2f1743bafd3 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -52,10 +52,13 @@ using namespace o2::framework::expressions; // Shorthand notations using FilteredColl = soa::Filtered>::iterator; using FilteredCollPartLevel = soa::Filtered>::iterator; +using FilteredCollPartLevelMB = soa::Filtered>::iterator; using FilteredCollDetLevelGetWeight = soa::Filtered>::iterator; + using FilteredEventMultiplicity = soa::Filtered>::iterator; using FilteredEventMultiplicityDetLevelGetWeight = soa::Filtered>::iterator; using FilteredEventMultiplicityPartLevel = soa::Filtered>::iterator; +using FilteredEventMultiplicityPartLevelMB = soa::Filtered::iterator; using FilteredJets = soa::Filtered>; using FilteredJetsDetLevel = soa::Filtered>; @@ -94,6 +97,11 @@ struct RecoilJets { "applied at the jet finder level, here rejection is applied for " "collision and track process functions"}; + 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 meanFT0A{"meanFT0A", -1., "Mean value of FT0A signal"}; Configurable meanFT0C{"meanFT0C", -1., "Mean value of FT0C signal"}; @@ -150,9 +158,19 @@ struct RecoilJets { Service pdg; Preslice partJetsPerCollision = aod::jet::mcCollisionId; + template + struct AxisDesc { + AxisDesc(const char* label_, const AxisObject& axis_, const std::string& axisName_ = "") + : label(label_), axis(axis_), axisName(axisName_) {}; + + const char* label; // "FT0C" / "FT0M" + const AxisObject& axis; // AxisSpec or ConfigurableAxis + std::string axisName; // Empty for AxisSpec + }; + void init(InitContext const&) { - // Initialize histogram axes + // 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"}; @@ -160,6 +178,19 @@ struct RecoilJets { AxisSpec scaledFT0M{histMultBins, 0.0, 20., "FT0M^{*}"}; AxisSpec zdcTiming{histZDCTimeBins, -30., 30., ""}; + // Fixed size histo + AxisSpec unscaledFT0A{2000, 0.0, 40000., "FT0A"}; + AxisSpec unscaledFT0C{2000, 0.0, 40000., "FT0C"}; + AxisSpec unscaledFT0M{3000, 0.0, 60000., "FT0M (FT0A + FT0C)"}; + + AxisSpec zdcNeutronA{1000, 0.0, 5000., "ZNA"}; + AxisSpec zdcNeutronC{1000, 0.0, 5000., "ZNC"}; + AxisSpec zdcNeutronM{4000, 0.0, 8000., "ZNM (ZNA + ZNC)"}; + + AxisSpec zdcProtonA{1000, 0.0, 5000., "ZPA"}; + AxisSpec zdcProtonC{1000, 0.0, 5000., "ZPC"}; + AxisSpec zdcProtonM{4000, 0.0, 8000., "ZPM (ZPA + ZPC)"}; + AxisSpec phiAngle{40, 0.0, constants::math::TwoPI, "#it{#varphi} (rad)"}; AxisSpec deltaPhiAngle{52, 0.0, constants::math::PI, "#Delta#it{#varphi} (rad)"}; AxisSpec pseudorap{40, -1., 1., "#it{#eta}"}; @@ -170,6 +201,28 @@ struct RecoilJets { std::string nameFT0Caxis = "FT0C / #LT FT0C #GT"; std::string nameFT0Maxis = "FT0M^{*}"; + std::array, 2> arrAxisSpecScaledEA = {{{"FT0C", scaledFT0C}, + {"FT0M", scaledFT0M}}}; + + std::array, 3> arrAxisSpecUnscaledEA = {{{"FT0A", unscaledFT0A}, + {"FT0C", unscaledFT0C}, + {"FT0M", unscaledFT0M}}}; + + std::array, 2> arrConfigurableAxis = {{{"FT0C", multFT0CThresh, nameFT0Caxis}, + {"FT0M", multFT0MThresh, nameFT0Maxis}}}; + + std::array, 2> arrConfigurableAxisPartLevel = {{{"FT0C", multFT0CThreshPartLevel, nameFT0Caxis}, + {"FT0M", multFT0MThreshPartLevel, nameFT0Maxis}}}; + + // Zero-degree calorimeter + std::array, 3> arrAxisSpecZDCNeutron = {{{"ZNA", zdcNeutronA}, + {"ZNC", zdcNeutronC}, + {"ZNM", zdcNeutronM}}}; + + std::array, 3> arrAxisSpecZDCProton = {{{"ZPA", zdcProtonA}, + {"ZPC", zdcProtonC}, + {"ZPM", zdcProtonM}}}; + // Convert configurable strings to std::string std::string evSelToString = static_cast(evSel); std::string trkSelToString = static_cast(trkSel); @@ -178,292 +231,429 @@ struct RecoilJets { trackSelection = jetderiveddatautilities::initialiseTrackSelection(trkSelToString); triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(triggerMasks); + const auto phiMin = phiRestrTTSelection->at(0); + const auto phiMax = phiRestrTTSelection->at(1); + // List of raw and MC det. distributions if (doprocessData || doprocessMCDetLevel || doprocessMCDetLevelWeighted) { - spectra.add("hEventSelectionCount", "Count # of events in the analysis", kTH1F, {{6, 0.0, 6.}}); + spectra.add("hEventSelectionCount", "Count # of events in the analysis", kTH1F, {{5, 0.0, 5.}}); spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(1, "Total # of events"); spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(2, Form("# of events after sel. %s", evSelToString.data())); - spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(3, "# of events skipMBGap"); - spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(4, "# of events w. outlier"); - spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(5, "# of events w/o assoc MC."); - spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(6, "# of selected events"); - - spectra.add("hScaledFT0C_vertexZ", "Z vertex of collisions", kTH2F, {{multFT0CThresh, nameFT0Caxis}, {60, -12., 12., "#it{z}_{vertex}"}}); - spectra.add("hScaledFT0M_vertexZ", "Z vertex of collisions", kTH2F, {{multFT0MThresh, nameFT0Maxis}, {60, -12., 12., "#it{z}_{vertex}"}}); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(3, "# of events w. outlier"); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(4, "# of events w/o assoc MC."); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(5, "# of selected events"); spectra.add("hTrackSelectionCount", "Count # of tracks in the analysis", kTH1F, {{2, 0.0, 2.}}); spectra.get(HIST("hTrackSelectionCount"))->GetXaxis()->SetBinLabel(1, "Total # of tracks"); spectra.get(HIST("hTrackSelectionCount"))->GetXaxis()->SetBinLabel(2, Form("# of tracks after sel. %s", trkSelToString.data())); - spectra.add("hScaledFT0CTrackPtEtaPhi", "Charact. of tracks", kTHnSparseF, {{multFT0CThresh, nameFT0Caxis}, pT, pseudorap, phiAngle}); - spectra.add("hScaledFT0MTrackPtEtaPhi", "Charact. of tracks", kTHnSparseF, {{multFT0MThresh, nameFT0Maxis}, pT, pseudorap, phiAngle}); 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("hScaledFT0C_Ntrig", "Total number of selected triggers per class vs scaled FT0C", kTH2F, {{multFT0CThresh, nameFT0Caxis}, {2, 0.0, 2.}}); - spectra.get(HIST("hScaledFT0C_Ntrig"))->GetYaxis()->SetBinLabel(1, "TT_{ref}"); - spectra.get(HIST("hScaledFT0C_Ntrig"))->GetYaxis()->SetBinLabel(2, "TT_{sig}"); + spectra.add("hJetPtEtaPhiRhoArea", "Charact. of inclusive jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}); + spectra.add("hJetArea_JetPt_Rho_TTRef", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); + spectra.add("hJetArea_JetPt_Rho_TTSig", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); - spectra.add("hScaledFT0M_Ntrig", "Total number of selected triggers per class vs scaled FT0M", kTH2F, {{multFT0MThresh, nameFT0Maxis}, {2, 0.0, 2.}}); - spectra.get(HIST("hScaledFT0M_Ntrig"))->GetYaxis()->SetBinLabel(1, "TT_{ref}"); - spectra.get(HIST("hScaledFT0M_Ntrig"))->GetYaxis()->SetBinLabel(2, "TT_{sig}"); + 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}"}}); - spectra.add("hScaledFT0C_TTRef_per_event", "Number of TT_{Ref} per event vs scaled FT0C", kTH2F, {{multFT0CThresh, nameFT0Caxis}, {15, 0.5, 15.5, "# of TT_{Ref}"}}); - spectra.add("hScaledFT0M_TTRef_per_event", "Number of TT_{Ref} per event vs scaled FT0M", kTH2F, {{multFT0MThresh, nameFT0Maxis}, {15, 0.5, 15.5, "# of TT_{Ref}"}}); + spectra.add(Form("hScaled%sTrackPtEtaPhi", eaAxis.label), + "Charact. of tracks", + kTHnSparseF, {{eaAxis.axis, eaAxis.axisName}, pT, pseudorap, phiAngle}); - spectra.add("hScaledFT0C_TTSig_per_event", "Number of TT_{Sig} per event vs scaled FT0C", kTH2F, {{multFT0CThresh, nameFT0Caxis}, {10, 0.5, 10.5, "# of TT_{Sig}"}}); - spectra.add("hScaledFT0M_TTSig_per_event", "Number of TT_{Sig} per event vs scaled FT0M", kTH2F, {{multFT0MThresh, nameFT0Maxis}, {10, 0.5, 10.5, "# of TT_{Sig}"}}); + auto tmpHistPointer = spectra.add(Form("hScaled%s_Ntrig", eaAxis.label), + Form("Total number of selected triggers per class vs scaled %s", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {2, 0.0, 2.}}); + tmpHistPointer->GetYaxis()->SetBinLabel(1, "TT_{Ref}"); + tmpHistPointer->GetYaxis()->SetBinLabel(2, "TT_{Sig}"); - spectra.add("hJetPtEtaPhiRhoArea", "Charact. of inclusive jets", kTHnSparseF, {pT, pseudorapJets, phiAngle, rho, jetArea}); + spectra.add(Form("hScaled%s_TTRef_per_event", eaAxis.label), + Form("Number of TT_{Ref} per event vs scaled %s", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {15, 0.5, 15.5, "# of TT_{Ref}"}}); - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTRef", "Events w. TT_{Ref}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThresh, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTRef", "Events w. TT_{Ref}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThresh, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); + spectra.add(Form("hScaled%s_TTSig_per_event", eaAxis.label), + Form("Number of TT_{Sig} per event vs scaled %s", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {10, 0.5, 10.5, "# of TT_{Sig}"}}); - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTSig", "Events w. TT_{Sig}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThresh, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTSig", "Events w. TT_{Sig}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThresh, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); + 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}); - spectra.add("hScaledFT0C_DPhi_JetPt_TTRef", "Events w. TT_{Ref}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThresh, nameFT0Caxis}, deltaPhiAngle, pT}); - spectra.add("hScaledFT0M_DPhi_JetPt_TTRef", "Events w. TT_{Ref}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThresh, nameFT0Maxis}, deltaPhiAngle, pT}); + 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}); - spectra.add("hScaledFT0C_DPhi_JetPt_TTSig", "Events w. TT_{Sig}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThresh, nameFT0Caxis}, deltaPhiAngle, pT}); - spectra.add("hScaledFT0M_DPhi_JetPt_TTSig", "Events w. TT_{Sig}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThresh, nameFT0Maxis}, deltaPhiAngle, pT}); + 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}); - spectra.add("hScaledFT0C_Recoil_JetPt_Corr_TTRef", "Events w. TT_{Ref}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThresh, nameFT0Caxis}, jetPTcorr}); - spectra.add("hScaledFT0M_Recoil_JetPt_Corr_TTRef", "Events w. TT_{Ref}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThresh, nameFT0Maxis}, jetPTcorr}); + 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}); - spectra.add("hScaledFT0C_Recoil_JetPt_Corr_TTSig", "Events w. TT_{Sig}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThresh, nameFT0Caxis}, jetPTcorr}); - spectra.add("hScaledFT0M_Recoil_JetPt_Corr_TTSig", "Events w. TT_{Sig}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThresh, nameFT0Maxis}, jetPTcorr}); + 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}); - spectra.add("hScaledFT0C_Recoil_JetPt_TTRef", "Events w. TT_{Ref}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThresh, nameFT0Caxis}, pT}); - spectra.add("hScaledFT0M_Recoil_JetPt_TTRef", "Events w. TT_{Ref}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThresh, nameFT0Maxis}, pT}); + 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}); - spectra.add("hScaledFT0C_Recoil_JetPt_TTSig", "Events w. TT_{Sig}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThresh, nameFT0Caxis}, pT}); - spectra.add("hScaledFT0M_Recoil_JetPt_TTSig", "Events w. TT_{Sig}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThresh, nameFT0Maxis}, pT}); + 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}); - spectra.add("hJetArea_JetPt_Rho_TTRef", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); - spectra.add("hJetArea_JetPt_Rho_TTSig", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); + 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}); - spectra.add("hScaledFT0C_Rho", "Scaled FT0C & #rho", kTH2F, {{multFT0CThresh, nameFT0Caxis}, rho}); - spectra.add("hScaledFT0M_Rho", "Scaled FT0M & #rho", kTH2F, {{multFT0MThresh, nameFT0Maxis}, rho}); + spectra.add(Form("hScaled%s_Rho", eaAxis.label), + Form("Scaled %s & #rho", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}); - spectra.add("hScaledFT0C_Rho_TTRef", "Events w. TT_{Ref}: scaled FT0C & #rho", kTH2F, {{multFT0CThresh, nameFT0Caxis}, rho}); - spectra.add("hScaledFT0M_Rho_TTRef", "Events w. TT_{Ref}: scaled FT0M & #rho", kTH2F, {{multFT0MThresh, nameFT0Maxis}, rho}); + 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}); - spectra.add("hScaledFT0C_Rho_TTSig", "Events w. TT_{Sig}: scaled FT0C & #rho", kTH2F, {{multFT0CThresh, nameFT0Caxis}, rho}); - spectra.add("hScaledFT0M_Rho_TTSig", "Events w. TT_{Sig}: scaled FT0M & #rho", kTH2F, {{multFT0MThresh, nameFT0Maxis}, rho}); + 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}); - spectra.add("hScaledFT0C_TTRef", "Events w. TT_{Ref}: scaled FT0C", kTH1F, {scaledFT0C}); - spectra.add("hScaledFT0M_TTRef", "Events w. TT_{Ref}: scaled FT0M", kTH1F, {scaledFT0M}); + 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}); - spectra.add("hScaledFT0C_TTSig", "Events w. TT_{Sig}: scaled FT0C", kTH1F, {scaledFT0C}); - spectra.add("hScaledFT0M_TTSig", "Events w. TT_{Sig}: scaled FT0M", kTH1F, {scaledFT0M}); + 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}); + } - // Rectricted phi range for TT selection - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTRef_RectrictedPhi", Form("Events w. TT_{Ref} #in #varphi (%.2f, %.2f): scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0CThresh, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTRef_RectrictedPhi", Form("Events w. TT_{Ref} #in #varphi (%.2f, %.2f): scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0MThresh, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); + for (const auto& eaAxis : arrAxisSpecScaledEA) { + spectra.add(Form("hScaled%s_TTRef", eaAxis.label), + Form("Events w. TT_{Ref}: scaled %s", eaAxis.label), + kTH1F, {eaAxis.axis}); - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTSig_RectrictedPhi", Form("Events w. TT_{Sig} #in #varphi (%.2f, %.2f): scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0CThresh, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTSig_RectrictedPhi", Form("Events w. TT_{Sig} #in #varphi (%.2f, %.2f): scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0MThresh, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); + spectra.add(Form("hScaled%s_TTSig", eaAxis.label), + Form("Events w. TT_{Sig}: scaled %s", eaAxis.label), + kTH1F, {eaAxis.axis}); + } } // List of MC particle level distributions if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { - spectra.add("hScaledFT0C_vertexZMC", "Z vertex of MCcollision", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, {60, -12., 12., "#it{z}_{vertex}"}}); - spectra.add("hScaledFT0M_vertexZMC", "Z vertex of MCcollision", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, {60, -12., 12., "#it{z}_{vertex}"}}); - spectra.add("ptHat", "Distribution of pT hat", kTH1F, {{5000, 0.0, 1000.}}); spectra.add("hEventSelectionCountPartLevel", "Count # of events in the part. level analysis", kTH1F, {{4, 0.0, 4.}}); spectra.get(HIST("hEventSelectionCountPartLevel"))->GetXaxis()->SetBinLabel(1, "Total # of events"); - spectra.get(HIST("hEventSelectionCountPartLevel"))->GetXaxis()->SetBinLabel(2, "# of events skipMB gap"); + spectra.get(HIST("hEventSelectionCountPartLevel"))->GetXaxis()->SetBinLabel(2, Form("# of events after sel. %s", evSelToString.data())); spectra.get(HIST("hEventSelectionCountPartLevel"))->GetXaxis()->SetBinLabel(3, "# of events w. outlier"); spectra.get(HIST("hEventSelectionCountPartLevel"))->GetXaxis()->SetBinLabel(4, "# of selected events"); - spectra.add("hScaledFT0CPartPtEtaPhi", "Charact. of particles", kTHnSparseF, {{multFT0CThreshPartLevel, nameFT0Caxis}, pT, pseudorap, phiAngle}); - spectra.add("hScaledFT0MPartPtEtaPhi", "Charact. of particles", kTHnSparseF, {{multFT0MThreshPartLevel, nameFT0Maxis}, pT, pseudorap, phiAngle}); - - spectra.add("hScaledFT0C_Ntrig_Part", "Total number of selected triggers per class vs scaled FT0C", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, {2, 0.0, 2.}}); - spectra.get(HIST("hScaledFT0C_Ntrig_Part"))->GetXaxis()->SetBinLabel(1, "TT_{ref}"); - spectra.get(HIST("hScaledFT0C_Ntrig_Part"))->GetXaxis()->SetBinLabel(2, "TT_{sig}"); - - spectra.add("hScaledFT0M_Ntrig_Part", "Total number of selected triggers per class vs scaled FT0M", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, {2, 0.0, 2.}}); - spectra.get(HIST("hScaledFT0M_Ntrig_Part"))->GetXaxis()->SetBinLabel(1, "TT_{ref}"); - spectra.get(HIST("hScaledFT0M_Ntrig_Part"))->GetXaxis()->SetBinLabel(2, "TT_{sig}"); - - spectra.add("hScaledFT0C_TTRef_per_event_Part", "Number of TT_{Ref} per event vs scaled FT0C", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, {15, 0.5, 15.5, "# of TT_{Ref}"}}); - spectra.add("hScaledFT0M_TTRef_per_event_Part", "Number of TT_{Ref} per event vs scaled FT0M", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, {15, 0.5, 15.5, "# of TT_{Ref}"}}); - - spectra.add("hScaledFT0C_TTSig_per_event_Part", "Number of TT_{Sig} per event vs scaled FT0C", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, {10, 0.5, 10.5, "# of TT_{Sig}"}}); - spectra.add("hScaledFT0M_TTSig_per_event_Part", "Number of TT_{Sig} per event vs scaled FT0M", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, {10, 0.5, 10.5, "# of TT_{Sig}"}}); + 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}); - - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThreshPartLevel, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThreshPartLevel, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); - - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThreshPartLevel, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThreshPartLevel, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); - - spectra.add("hScaledFT0C_DPhi_JetPt_TTRef_Part", "Events w. TT_{Ref}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThreshPartLevel, nameFT0Caxis}, deltaPhiAngle, pT}); - spectra.add("hScaledFT0M_DPhi_JetPt_TTRef_Part", "Events w. TT_{Ref}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThreshPartLevel, nameFT0Maxis}, deltaPhiAngle, pT}); - - spectra.add("hScaledFT0C_DPhi_JetPt_TTSig_Part", "Events w. TT_{Sig}: scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0CThreshPartLevel, nameFT0Caxis}, deltaPhiAngle, pT}); - spectra.add("hScaledFT0M_DPhi_JetPt_TTSig_Part", "Events w. TT_{Sig}: scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", kTH3F, {{multFT0MThreshPartLevel, nameFT0Maxis}, deltaPhiAngle, pT}); - - spectra.add("hScaledFT0C_Recoil_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, jetPTcorr}); - spectra.add("hScaledFT0M_Recoil_JetPt_Corr_TTRef_Part", "Events w. TT_{Ref}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, jetPTcorr}); - - spectra.add("hScaledFT0C_Recoil_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, jetPTcorr}); - spectra.add("hScaledFT0M_Recoil_JetPt_Corr_TTSig_Part", "Events w. TT_{Sig}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, jetPTcorr}); - - spectra.add("hScaledFT0C_Recoil_JetPt_TTRef_Part", "Events w. TT_{Ref}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, pT}); - spectra.add("hScaledFT0M_Recoil_JetPt_TTRef_Part", "Events w. TT_{Ref}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, pT}); - - spectra.add("hScaledFT0C_Recoil_JetPt_TTSig_Part", "Events w. TT_{Sig}: scaled FT0C & #it{p}_{T} of recoil jets", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, pT}); - spectra.add("hScaledFT0M_Recoil_JetPt_TTSig_Part", "Events w. TT_{Sig}: scaled FT0M & #it{p}_{T} of recoil jets", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, pT}); - spectra.add("hJetArea_JetPt_Rho_TTRef_Part", "Events w. TT_{Ref}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); spectra.add("hJetArea_JetPt_Rho_TTSig_Part", "Events w. TT_{Sig}: A_{jet} & jet pT & #rho", kTH3F, {jetArea, pT, rho}); - spectra.add("hScaledFT0C_Rho_Part", "Scaled FT0C & #rho", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, rho}); - spectra.add("hScaledFT0M_Rho_Part", "Scaled FT0M & #rho", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, rho}); - - spectra.add("hScaledFT0C_Rho_TTRef_Part", "Events w. TT_{Ref}: scaled FT0C & #rho", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, rho}); - spectra.add("hScaledFT0M_Rho_TTRef_Part", "Events w. TT_{Ref}: scaled FT0M & #rho", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, rho}); - - spectra.add("hScaledFT0C_Rho_TTSig_Part", "Events w. TT_{Sig}: scaled FT0C & #rho", kTH2F, {{multFT0CThreshPartLevel, nameFT0Caxis}, rho}); - spectra.add("hScaledFT0M_Rho_TTSig_Part", "Events w. TT_{Sig}: scaled FT0M & #rho", kTH2F, {{multFT0MThreshPartLevel, nameFT0Maxis}, rho}); - - spectra.add("hScaledFT0C_TTRef_Part", "Events w. TT_{Ref}: scaled FT0C", kTH1F, {scaledFT0C}); - spectra.add("hScaledFT0M_TTRef_Part", "Events w. TT_{Ref}: scaled FT0M", kTH1F, {scaledFT0M}); - - spectra.add("hScaledFT0C_TTSig_Part", "Events w. TT_{Sig}: scaled FT0C", kTH1F, {scaledFT0C}); - spectra.add("hScaledFT0M_TTSig_Part", "Events w. TT_{Sig}: scaled FT0M", kTH1F, {scaledFT0M}); + 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}"}}); + + auto tmpHistPointer = spectra.add(Form("hScaled%s_Ntrig_Part", eaAxis.label), + Form("Total number of selected triggers per class vs scaled %s", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {2, 0.0, 2.}}); + tmpHistPointer->GetYaxis()->SetBinLabel(1, "TT_{Ref}"); + tmpHistPointer->GetYaxis()->SetBinLabel(2, "TT_{Sig}"); + + spectra.add(Form("hScaled%sPartPtEtaPhi", eaAxis.label), + "Charact. of particles", + kTHnSparseF, {{eaAxis.axis, eaAxis.axisName}, pT, pseudorap, phiAngle}); + + spectra.add(Form("hScaled%s_TTRef_per_event_Part", eaAxis.label), + Form("Number of TT_{Ref} per event vs scaled %s", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {15, 0.5, 15.5, "# of TT_{Ref}"}}); + + spectra.add(Form("hScaled%s_TTSig_per_event_Part", eaAxis.label), + Form("Number of TT_{Sig} per event vs scaled %s", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, {10, 0.5, 10.5, "# of TT_{Sig}"}}); + + 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}); + + 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}); + + 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}); + + 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}); + + 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}); + + 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}); + + 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}); + + 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}); + + spectra.add(Form("hScaled%s_Rho_Part", eaAxis.label), + Form("Scaled %s & #rho", eaAxis.label), + kTH2F, {{eaAxis.axis, eaAxis.axisName}, rho}); + + 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}); + + 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}); + + // 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}); + + 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}); + } - // Rectricted phi range for TT selection - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTRef_RectrictedPhi_Part", Form("Events w. TT_{Ref} #in #varphi (%.2f, %.2f): scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0CThreshPartLevel, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTRef_RectrictedPhi_Part", Form("Events w. TT_{Ref} #in #varphi (%.2f, %.2f): scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0MThreshPartLevel, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); + for (const auto& eaAxis : arrAxisSpecScaledEA) { + spectra.add(Form("hScaled%s_TTRef_Part", eaAxis.label), + Form("Events w. TT_{Ref}: scaled %s", eaAxis.label), + kTH1F, {eaAxis.axis}); - spectra.add("hScaledFT0C_DPhi_JetPt_Corr_TTSig_RectrictedPhi_Part", Form("Events w. TT_{Sig} #in #varphi (%.2f, %.2f): scaled FT0C & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0CThreshPartLevel, nameFT0Caxis}, deltaPhiAngle, jetPTcorr}); - spectra.add("hScaledFT0M_DPhi_JetPt_Corr_TTSig_RectrictedPhi_Part", Form("Events w. TT_{Sig} #in #varphi (%.2f, %.2f): scaled FT0M & #Delta#varphi & #it{p}_{T, jet}^{ch}", phiRestrTTSelection->at(0), phiRestrTTSelection->at(1)), kTH3F, {{multFT0MThreshPartLevel, nameFT0Maxis}, deltaPhiAngle, jetPTcorr}); + spectra.add(Form("hScaled%s_TTSig_Part", eaAxis.label), + Form("Events w. TT_{Sig}: scaled %s", eaAxis.label), + kTH1F, {eaAxis.axis}); + } } // 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.}}); - // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel", "Correlation jet pT at - // part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); - 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.}}); + spectra.add("hJetPt_DetLevel_vs_PartLevel", + "Correlation jet pT at det. vs. part. levels", + kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}); + + // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel", + // "Correlation jet pT at part. vs. det. levels", + // kTH2F, {jetPTcorr, jetPTcorr}); + + 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.}}); // spectra.add("hJetPt_Corr_PartLevel_vs_DetLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {jetPTcorr, jetPTcorr}); - spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + spectra.add("hMissedJets_pT", + "Part. level jets w/o matched pair", + kTH1F, {{200, 0.0, 200.}}); + // spectra.add("hMissedJets_Corr_pT", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); - spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + spectra.add("hMissedJets_pT_RecoilJets", + "Part. level jets w/o matched pair", + kTH1F, {{200, 0.0, 200.}}); // spectra.add("hMissedJets_Corr_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {jetPTcorr}); - spectra.add("hFakeJets_pT", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + spectra.add("hFakeJets_pT", + "Det. level jets w/o matched pair", + kTH1F, {{200, 0.0, 200.}}); // spectra.add("hFakeJets_Corr_pT", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); - spectra.add("hFakeJets_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}); + spectra.add("hFakeJets_pT_RecoilJets", + "Det. level jets w/o matched pair", + kTH1F, {{200, 0.0, 200.}}); // spectra.add("hFakeJets_Corr_pT_RecoilJets", "Det. level jets w/o matched pair", kTH1F, {jetPTcorr}); - spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}); - spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}); + spectra.add("hJetPt_resolution", + "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", + kTH2F, {{100, -5., 5.}, pT}); - spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); - spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}); + spectra.add("hJetPt_resolution_RecoilJets", + "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", + kTH2F, {{100, -5., 5.}, pT}); - spectra.add("hNumberMatchedJetsPerOneBaseJet", "# of tagged jets per 1 base jet vs. jet pT", kTH2F, {{10, 0.5, 10.5}, {100, 0.0, 100.}}); - } - - // Multiplicity for raw data and detector level MC - if (doprocessMultiplicityOO || doprocessMultiplicityMCDetLevelWeightedOO) { - spectra.add("hMultFT0A", "Mult. signal from FTOA", kTH1F, {{2000, 0.0, 40000., "FT0A"}}); - spectra.add("hMultFT0C", "Mult. signal from FTOC", kTH1F, {{2000, 0.0, 40000., "FT0C"}}); - spectra.add("hMultFT0M", "Total mult. signal from FT0A & FTOC", kTH1F, {{3000, 0.0, 60000., "FT0M"}}); + spectra.add("hJetPhi_resolution", + "#varphi resolution as a func. of jet #it{p}_{T, part}", + kTH2F, {{40, -1., 1.}, pT}); - spectra.add("hScaleMultFT0A", "Scaled mult. signal from FTOA", kTH1F, {scaledFT0A}); - spectra.add("hScaleMultFT0C", "Scaled mult. signal from FTOC", kTH1F, {scaledFT0C}); - spectra.add("hScaleMultFT0M", "Scaled total mult. signal from FT0A & FTOC", kTH1F, {scaledFT0M}); + spectra.add("hJetPhi_resolution_RecoilJets", + "#varphi resolution as a func. of jet #it{p}_{T, part}", + kTH2F, {{40, -1., 1.}, pT}); - spectra.add("hMultZNA", "Mult. signal from ZDC A-side", kTH1F, {{1000, 0.0, 5000., "ZNA"}}); - spectra.add("hMultZNC", "Mult. signal from ZDC C-side", kTH1F, {{1000, 0.0, 5000., "ZNC"}}); - spectra.add("hMultZNM", "Total mult. signal from ZDCs for neutrons", kTH1F, {{4000, 0.0, 8000., "ZNM"}}); + spectra.add("hNumberMatchedJetsPerOneBaseJet", + "# of tagged jets per 1 base jet vs. jet pT", + kTH2F, {{10, 0.5, 10.5}, {100, 0.0, 100.}}); + } - spectra.add("hMultZPA", "Mult. signal from ZDC A-side", kTH1F, {{1000, 0.0, 5000., "ZPA"}}); - spectra.add("hMultZPC", "Mult. signal from ZDC C-side", kTH1F, {{1000, 0.0, 5000., "ZPC"}}); - spectra.add("hMultZPM", "Total mult. signal from ZDCs for protons", kTH1F, {{4000, 0.0, 8000., "ZPM"}}); + // Multiplicity for raw data and detector level MC + if (doprocessEventActivityOO || doprocessEventActivityMCDetLevelWeightedOO) { + + //==================================================================================== + // FIT data + for (const auto& eaAxis : arrAxisSpecUnscaledEA) { + spectra.add(Form("hMult%s", eaAxis.label), + Form("Mult. signal %s", eaAxis.label), + kTH1F, {eaAxis.axis}); + } - // Correlations - spectra.add("hZPA_vs_ZNA", "Correlation of signals ZPA vs ZNA", kTH2F, {{1000, 0.0, 5000., "ZPA"}, {1000, 0.0, 5000., "ZNA"}}); - spectra.add("hZPC_vs_ZNC", "Correlation of signals ZPC vs ZNC", kTH2F, {{1000, 0.0, 5000., "ZPC"}, {1000, 0.0, 5000., "ZNC"}}); + spectra.add("hScaleMultFT0A", "Scaled FTOA signal", kTH1F, {scaledFT0A}); + for (const auto& eaAxis : arrAxisSpecScaledEA) { + spectra.add(Form("hScaleMult%s", eaAxis.label), + Form("Scaled %s signal", eaAxis.label), + kTH1F, {eaAxis.axis}); + } - spectra.add("hMultFT0A_vs_ZNA", "Correlation of signals FTOA vs ZNA", kTH2F, {{2000, 0.0, 40000., "FT0A"}, {1000, 0.0, 5000., "ZNA"}}); - spectra.add("hMultFT0C_vs_ZNC", "Correlation of signals FTOC vs ZNC", kTH2F, {{2000, 0.0, 40000., "FT0C"}, {1000, 0.0, 5000., "ZNC"}}); - spectra.add("hMultFT0M_vs_ZNM", "Correlation of signals FTOM vs ZNM", kTH2F, {{3000, 0.0, 60000., "FT0M"}, {4000, 0.0, 8000., "ZNM"}}); + //==================================================================================== + // Zero-degree calorimeter data + 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}); + + spectra.add(Form("hMult%s", arrAxisSpecZDCProton[i].label), + Form("Mult. signal from %s", arrAxisSpecZDCProton[i].label), + kTH1F, {arrAxisSpecZDCProton[i].axis}); + + // 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}}); + } - spectra.add("hScaleMultFT0A_vs_ZNA", "Correlation of signals FT0A/meanFT0A vs ZNA", kTH2F, {{scaledFT0A}, {1000, 0.0, 5000., "ZNA"}}); - spectra.add("hScaleMultFT0C_vs_ZNC", "Correlation of signals FT0C/meanFT0C vs ZNC", kTH2F, {{scaledFT0C}, {1000, 0.0, 5000., "ZNC"}}); - spectra.add("hScaleMultFT0M_vs_ZNM", "Correlation of signals FT0M^{*} vs ZNM", kTH2F, {{scaledFT0M}, {4000, 0.0, 8000., "ZNM"}}); + //==================================================================================== + // FT0 vs. ZDC correlation + 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}}); + + 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}}); + + 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}}); + } else { + spectra.add("hScaleMultFT0A_vs_ZNA", "Correlation of signals scaled FT0A vs ZNA", kTH2F, {{scaledFT0A}, {arrAxisSpecZDCNeutron[i].axis}}); + spectra.add("hScaleMultFT0A_vs_ZPA", "Correlation of signals scaled FT0A vs ZPA", kTH2F, {{scaledFT0A}, {arrAxisSpecZDCProton[i].axis}}); + } + } - spectra.add("hScaleMultFT0A_vs_ZPA", "Correlation of signals FT0A/meanFT0A vs ZPA", kTH2F, {{scaledFT0A}, {1000, 0.0, 5000., "ZPA"}}); - spectra.add("hScaleMultFT0C_vs_ZPC", "Correlation of signals FT0C/meanFT0C vs ZPC", kTH2F, {{scaledFT0C}, {1000, 0.0, 5000., "ZPC"}}); - spectra.add("hScaleMultFT0M_vs_ZPM", "Correlation of signals FT0M^{*} vs ZPM", kTH2F, {{scaledFT0M}, {4000, 0.0, 8000., "ZPM"}}); + 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"}}); - 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"}}); - 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"}}); + 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"}}); } // Multiplicity for particle level MC - if (doprocessMultiplicityPartLevelMC || doprocessMultiplicityPartLevelMCWeighted) { - spectra.add("hMultFT0APartLevel", "# of primary particles within FTOA acceptance", kTH1F, {{2000, 0.0, 500., "FT0A"}}); - spectra.add("hMultFT0CPartLevel", "# of primary particles within FTOC acceptance", kTH1F, {{2000, 0.0, 500., "FT0C"}}); - spectra.add("hMultFT0MPartLevel", "Total # of primary particles from FT0A & FTOC", kTH1F, {{4000, 0.0, 1000., "FT0M"}}); - - spectra.add("hScaleMultFT0APartLevel", "Scaled # of primary particles within FTOA acceptance", kTH1F, {scaledFT0A}); - spectra.add("hScaleMultFT0CPartLevel", "Scaled # of primary particles within FTOC acceptance", kTH1F, {scaledFT0C}); - spectra.add("hScaleMultFT0MPartLevel", "Scaled total # of primary particles from FT0A & FTOC", kTH1F, {scaledFT0M}); + if (doprocessEventActivityMCPartLevel || doprocessEventActivityMCPartLevelWeighted) { + spectra.add("hMultFT0APartLevel", "# of primary particles within FTOA acceptance", kTH1F, {{2000, 0.0, 1000., "FT0A"}}); + spectra.add("hMultFT0CPartLevel", "# of primary particles within FTOC acceptance", kTH1F, {{2000, 0.0, 1000., "FT0C"}}); + spectra.add("hMultFT0MPartLevel", "Total # of primary particles from FT0A & FTOC", kTH1F, {{4000, 0.0, 2000., "FT0M"}}); + + spectra.add("hScaleMultFT0APartLevel", "Scaled # of primary particles within FTOA acceptance", kTH1F, {{scaledFT0A}}); + 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}}); + } } - if (doprocessMultiplicityQA) { - - // ZNC timing QA - spectra.add("hTimeCorrZnaZnc", "Correlat. #it{t}_{ZNA} - #it{t}_{ZNC} vs. #it{t}_{ZNA} + #it{t}_{ZNC}", kTH2F, {{1000, -10., 10., "#it{t}_{ZNA} - #it{t}_{ZNC} (ns)"}, {1000, -10., 10., "#it{t}_{ZNA} + #it{t}_{ZNC} (ns)"}}); - spectra.add("hTimeZnaVsZncVsFT0C", "Correlat. #it{t}_{ZNA} (ns) vs. #it{t}_{ZNC} (ns) vs. FT0C/meanFT0C", kTH3F, {{zdcTiming}, {zdcTiming}, {scaledFT0C}}); - spectra.add("hTimeZnaVsZncVsFT0M", "Correlat. #it{t}_{ZNA} (ns) vs. #it{t}_{ZNC} (ns) vs. FT0M^{*}", kTH3F, {{zdcTiming}, {zdcTiming}, {scaledFT0M}}); - - // Number of tracks from PV within acceptance |eta| < 0.8 - spectra.add("hScaledFT0C_TracksPV", "Correlat. FT0C/meanFT0C vs. PV tracks", kTH2F, {{scaledFT0C}, {5000, 0., 5000.}}); - spectra.add("hScaledFT0M_TracksPV", "Correlat. FT0M^{*} vs. PV tracks", kTH2F, {{scaledFT0M}, {5000, 0., 5000.}}); - - // ITS-only tracks - spectra.add("hScaledFT0C_ITStracks", "Correlat. FT0C/meanFT0C vs. number of ITS tracks", kTH2F, {{scaledFT0C}, {5000, 0., 5000.}}); - spectra.add("hScaledFT0M_ITStracks", "Correlat. FT0M^{*} vs. number of ITS tracks", kTH2F, {{scaledFT0M}, {5000, 0., 5000.}}); + if (doprocessEventActivityQA) { + spectra.add("hEventSelectionCount", "Count # of events in the analysis", kTH1F, {{5, 0.0, 5.}}); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(1, "sel8"); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(2, "IsGoodZvtxFT0vsPV"); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(3, "NoSameBunchPileup"); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(4, "NoCollInTimeRangeStandard"); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(5, "All flags"); + + //==================================================================================== + // 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)"}}); + 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}}); + + // 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.}}); + + // 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.}}); + } - // Multiplicity equalized for the vertex position with FT0 detector - spectra.add("hMultZeqFT0A", "Equalized mult. FT0A", kTH1F, {{{2000, 0.0, 40000., "FT0A"}}}); - spectra.add("hMultZeqFT0C", "Equalized mult. FT0C", kTH1F, {{{2000, 0.0, 40000., "FT0C"}}}); - spectra.add("hMultZeqFT0M", "Equalized mult. FT0M", kTH1F, {{{3000, 0.0, 60000., "FT0M"}}}); + //==================================================================================== + // EA equalized for the vertex position with FT0 detector + for (const auto& eaAxis : arrAxisSpecUnscaledEA) { + spectra.add(Form("hMultZeq%s", eaAxis.label), + Form("Equalized mult. %s", eaAxis.label), + kTH1F, {{eaAxis.axis}}); + } - spectra.add("hScaledZeqFT0A", "Equalized FT0A/meanFT0A", kTH1F, {{scaledFT0A}}); - spectra.add("hScaledZeqFT0C", "Equalized FT0C/meanFT0C", kTH1F, {{scaledFT0C}}); - spectra.add("hScaledZeqFT0M", "Equalized FT0M^{*}", kTH1F, {{scaledFT0M}}); + // Scaled EA + spectra.add("hScaledZeqFT0A", "Equalized scaled FT0A", kTH1F, {{scaledFT0A}}); + for (const auto& eaAxis : arrAxisSpecScaledEA) { + spectra.add(Form("hScaledZeq%s", eaAxis.label), + Form("Equalized scaled %s", eaAxis.label), + kTH1F, {{eaAxis.axis}}); + } + //==================================================================================== // Run-by-run study of EA std::vector runNumbersOO = { "564356", "564359", "564373", "564374", "564387", "564400", "564414", "564430", "564445"}; const int nRunsOO = runNumbersOO.size(); std::vector evSelFlags = { - "sel8", "sel8 + IsGoodZvtxFT0vsPV", "sel8 + NoSameBunchPileup", "sel8 + IsGoodZvtxFT0vsPV + NoSameBunchPileup"}; + "sel8", "sel8 + IsGoodZvtxFT0vsPV", "sel8 + NoSameBunchPileup", "NoCollInTimeRangeStandard", "sel8 && IsGoodZvtxFT0vsPV && NoSameBunchPileup && NoCollInTimeRangeStandard"}; const int nEvSelFlags = evSelFlags.size(); - // Scaled FT0 signal - spectra.add("hScaledFT0APerRunPerSetOfFlags", "FT0A/meanFT0A signal per run per set of ev. sel. flags", kTH3F, {{scaledFT0A}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}); - spectra.add("hScaledFT0CPerRunPerSetOfFlags", "FT0C/meanFT0C signal per run per set of ev. sel. flags", kTH3F, {{scaledFT0C}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}); - spectra.add("hScaledFT0MPerRunPerSetOfFlags", "FT0M^{*} signal per run per set of ev. sel. flags", kTH3F, {{scaledFT0M}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}); + // 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.}}); + 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.}}); + setBinLablesYZaxes(tmpHistPointer, runNumbersOO, evSelFlags); + } // Unscaled FT0 signal; check whether mean value is the same for all runs - spectra.add("hFT0APerRunPerSetOfFlags", "FT0A signal per run per set of ev. sel. flags", kTH3F, {{2000, 0.0, 40000., "FT0A"}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}); - spectra.add("hFT0CPerRunPerSetOfFlags", "FT0C signal per run per set of ev. sel. flags", kTH3F, {{2000, 0.0, 40000., "FT0C"}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}); - spectra.add("hFT0MPerRunPerSetOfFlags", "FT0M signal per run per set of ev. sel. flags", kTH3F, {{3000, 0.0, 60000., "FT0M"}, {nRunsOO, 0., nRunsOO * 1.}, {nEvSelFlags, 0., nEvSelFlags * 1.}}); + 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.}}); + setBinLablesYZaxes(tmpHistPointer, runNumbersOO, evSelFlags); + } // Check whether each BC has FT0 signal spectra.add("hIsFT0SignalComeFromCollPerRun", "", kTH2F, {{4, 0., 4.}, {nRunsOO, 0., nRunsOO * 1.}}); @@ -471,72 +661,100 @@ struct RecoilJets { spectra.get(HIST("hIsFT0SignalComeFromCollPerRun"))->GetXaxis()->SetBinLabel(2, "BC has not FT0"); spectra.get(HIST("hIsFT0SignalComeFromCollPerRun"))->GetXaxis()->SetBinLabel(3, "Coll. w. BC"); spectra.get(HIST("hIsFT0SignalComeFromCollPerRun"))->GetXaxis()->SetBinLabel(4, "Coll. w/o BC"); + setBinLablesYZaxes(spectra.get(HIST("hIsFT0SignalComeFromCollPerRun")), runNumbersOO, {}); // FT0 signal for the case when there is no associated BC - spectra.add("hFT0AsignalWithoutBC", "", kTH2F, {{2000, 0.0, 40000., "FT0A"}, {nRunsOO, 0., nRunsOO * 1.}}); - spectra.add("hFT0CsignalWithoutBC", "", kTH2F, {{2000, 0.0, 40000., "FT0C"}, {nRunsOO, 0., nRunsOO * 1.}}); - spectra.add("hFT0MsignalWithoutBC", "", kTH2F, {{2000, 0.0, 40000., "FT0M"}, {nRunsOO, 0., nRunsOO * 1.}}); - - // Rename Y axis with Run numbers - for (int iRun = 0; iRun < nRunsOO; ++iRun) { - spectra.get(HIST("hScaledFT0APerRunPerSetOfFlags"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); - spectra.get(HIST("hScaledFT0CPerRunPerSetOfFlags"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); - spectra.get(HIST("hScaledFT0MPerRunPerSetOfFlags"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); + spectra.add("hScaledFT0AsignalWithoutBC", "", kTH2F, {{scaledFT0A}, {nRunsOO, 0., nRunsOO * 1.}}); + setBinLablesYZaxes(spectra.get(HIST("hScaledFT0AsignalWithoutBC")), runNumbersOO, {}); + + for (const auto& eaAxis : arrAxisSpecScaledEA) { + auto tmpHistPointer = spectra.add(Form("hScaled%ssignalWithoutBC", eaAxis.label), + "", + kTH2F, {{eaAxis.axis}, {nRunsOO, 0., nRunsOO * 1.}}); + setBinLablesYZaxes(tmpHistPointer, runNumbersOO, {}); + } + } - spectra.get(HIST("hFT0APerRunPerSetOfFlags"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); - spectra.get(HIST("hFT0CPerRunPerSetOfFlags"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); - spectra.get(HIST("hFT0MPerRunPerSetOfFlags"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); + // Di-hadron correlation + if (doprocessLeadingAndAssociatedTracksTask) { + const auto pTLeadTrackMin = pTLeadTrack->at(0); + const auto pTLeadTrackMax = pTLeadTrack->at(1); - spectra.get(HIST("hIsFT0SignalComeFromCollPerRun"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); + 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.}}); - spectra.get(HIST("hFT0AsignalWithoutBC"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); - spectra.get(HIST("hFT0CsignalWithoutBC"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); - spectra.get(HIST("hFT0MsignalWithoutBC"))->GetYaxis()->SetBinLabel(iRun + 1, runNumbersOO[iRun]); + 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)"}}); } + } - // Rename Z axis with event selection flags - for (int iFlag = 0; iFlag < nEvSelFlags; ++iFlag) { - spectra.get(HIST("hScaledFT0APerRunPerSetOfFlags"))->GetZaxis()->SetBinLabel(iFlag + 1, evSelFlags[iFlag]); - spectra.get(HIST("hScaledFT0CPerRunPerSetOfFlags"))->GetZaxis()->SetBinLabel(iFlag + 1, evSelFlags[iFlag]); - spectra.get(HIST("hScaledFT0MPerRunPerSetOfFlags"))->GetZaxis()->SetBinLabel(iFlag + 1, evSelFlags[iFlag]); + // Bkgd fluctuations in raw and MC det. level data + const auto ptTTsigMin = ptTTsig->at(0); + const auto ptTTsigMax = ptTTsig->at(1); - spectra.get(HIST("hFT0APerRunPerSetOfFlags"))->GetZaxis()->SetBinLabel(iFlag + 1, evSelFlags[iFlag]); - spectra.get(HIST("hFT0CPerRunPerSetOfFlags"))->GetZaxis()->SetBinLabel(iFlag + 1, evSelFlags[iFlag]); - spectra.get(HIST("hFT0MPerRunPerSetOfFlags"))->GetZaxis()->SetBinLabel(iFlag + 1, evSelFlags[iFlag]); - } - } + 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})"}}); - if (doprocessLeadingAndAssociatedTracksTask) { + 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})"}}); - spectra.add("hScaledFT0C_NleadTracks", "Total number of selected leading tracks vs scaled FT0C", kTH2F, {{scaledFT0C}, {1, 0.0, 1.}}); - spectra.add("hScaledFT0M_NleadTracks", "Total number of selected leading tracks vs scaled FT0M", kTH2F, {{scaledFT0M}, {1, 0.0, 1.}}); + 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})"}}); - spectra.add("hScaledFT0C_Correlation_LeadTrack_AssociatTracks", Form("Leading track #it{p}_{T} #in (%.2f, %.2f); Associated track #it{p}_{T} #in (%.2f, #it{p}_{T, lead. trk})", pTLeadTrack->at(0), pTLeadTrack->at(1), pTAssociatTrackMin.value), kTH2F, {{scaledFT0C}, {160, -1.28, 5.0, "#it{#varphi} (rad)"}}); - spectra.add("hScaledFT0M_Correlation_LeadTrack_AssociatTracks", Form("Leading track #it{p}_{T} #in (%.2f, %.2f); Associated track #it{p}_{T} #in (%.2f, #it{p}_{T, lead. trk})", pTLeadTrack->at(0), pTLeadTrack->at(1), pTAssociatTrackMin.value), kTH2F, {{scaledFT0M}, {160, -1.28, 5.0, "#it{#varphi} (rad)"}}); + 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})"}}); + + 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})"}}); + } } - if (doprocessBkgdFluctuationsRC) { - spectra.add("hScaledFT0C_deltaPtRandomCone", Form("Bkgd fluctuations RC with #it{R} = %.1f vs. EA", randomConeR.value), kTH2F, {{scaledFT0C}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); - spectra.add("hScaledFT0M_deltaPtRandomCone", Form("Bkgd fluctuations RC with #it{R} = %.1f vs. EA", randomConeR.value), kTH2F, {{scaledFT0M}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); + // Bkgd fluctuations in MC part. level data + 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})"}}); - spectra.add("hScaledFT0C_deltaPtRandomConeAvoidLeadJet", Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), kTH2F, {{scaledFT0C}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); - spectra.add("hScaledFT0M_deltaPtRandomConeAvoidLeadJet", Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), kTH2F, {{scaledFT0M}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); + 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})"}}); - spectra.add("hScaledFT0C_deltaPtPerpConeAvoidLeadJet", Form("Bkgd fluctuations PC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), kTH2F, {{scaledFT0C}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); - spectra.add("hScaledFT0M_deltaPtPerpConeAvoidLeadJet", Form("Bkgd fluctuations PC with #it{R} = %.1f avoid lead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), kTH2F, {{scaledFT0M}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); + 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})"}}); - spectra.add("hScaledFT0C_deltaPtRandomConeAvoidLeadAndSubleadJet", Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead, sublead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), kTH2F, {{scaledFT0C}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); - spectra.add("hScaledFT0M_deltaPtRandomConeAvoidLeadAndSubleadJet", Form("Bkgd fluctuations RC with #it{R} = %.1f avoid lead, sublead jet in vic. %.1f vs. EA", randomConeR.value, randomConeJetDeltaR.value), kTH2F, {{scaledFT0M}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); + 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})"}}); - spectra.add("hScaledFT0C_deltaPtRandomConeInEventTTSig", Form("Bkgd fluctuations RC with #it{R} = %.1f in events with TT{%.0f, %.0f} in vic. %.1f vs. EA", randomConeR.value, ptTTsig->at(0), ptTTsig->at(1), randomConeJetDeltaR.value), kTH2F, {{scaledFT0C}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); - spectra.add("hScaledFT0M_deltaPtRandomConeInEventTTSig", Form("Bkgd fluctuations RC with #it{R} = %.1f in events with TT{%.0f, %.0f} in vic. %.1f vs. EA", randomConeR.value, ptTTsig->at(0), ptTTsig->at(1), randomConeJetDeltaR.value), kTH2F, {{scaledFT0M}, {400, -40., 60., "#delta#it{p}_{T} (GeV/#it{c})"}}); + 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})"}}); + } } } + //============================================================================= + // Recoil jet analysis + //============================================================================= + // Fill histograms with raw or MC det. level data template - void fillHistograms(JCollision const& collision, Jets const& jets, - JTracks const& tracks, float weight = 1.) + void fillHistograms(JCollision const& collision, + Jets const& jets, + JTracks const& tracks, + float weight = 1.) { bool bSigEv = false; std::vector vPhiOfTT; @@ -570,13 +788,17 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0MTrackPtEtaPhi"), scaledFT0M, trackPt, track.eta(), trackPhi, weight); // Search for TT candidate - if (bSigEv && (trackPt > ptTTsig->at(0) && trackPt < ptTTsig->at(1))) { + const auto ptTTsigMin = ptTTsig->at(0); + const auto ptTTsigMax = ptTTsig->at(1); + if (bSigEv && (trackPt > ptTTsigMin && trackPt < ptTTsigMax)) { vPhiOfTT.push_back(trackPhi); spectra.fill(HIST("hTTSig_pT"), trackPt, weight); ++nTT; } - if (!bSigEv && (trackPt > ptTTref->at(0) && trackPt < ptTTref->at(1))) { + const auto ptTTrefMin = ptTTref->at(0); + const auto ptTTrefMax = ptTTref->at(1); + if (!bSigEv && (trackPt > ptTTrefMin && trackPt < ptTTrefMax)) { vPhiOfTT.push_back(trackPhi); ++nTT; } @@ -623,6 +845,9 @@ 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); + auto [dphi, bRecoilJet] = isRecoilJet(jet, phiTT); if (bSigEv) { @@ -633,7 +858,7 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0M_DPhi_JetPt_TTSig"), scaledFT0M, dphi, jetPt, weight); spectra.fill(HIST("hJetArea_JetPt_Rho_TTSig"), jetArea, jetPt, rho, weight); - if (phiTT > phiRestrTTSelection->at(0) && phiTT < phiRestrTTSelection->at(1)) { + if (phiTT > phiMin && phiTT < phiMax) { spectra.fill(HIST("hScaledFT0C_DPhi_JetPt_Corr_TTSig_RectrictedPhi"), scaledFT0C, dphi, jetPtCorr, weight); spectra.fill(HIST("hScaledFT0M_DPhi_JetPt_Corr_TTSig_RectrictedPhi"), scaledFT0M, dphi, jetPtCorr, weight); } @@ -653,7 +878,7 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0M_DPhi_JetPt_TTRef"), scaledFT0M, dphi, jetPt, weight); spectra.fill(HIST("hJetArea_JetPt_Rho_TTRef"), jetArea, jetPt, rho, weight); - if (phiTT > phiRestrTTSelection->at(0) && phiTT < phiRestrTTSelection->at(1)) { + if (phiTT > phiMin && phiTT < phiMax) { spectra.fill(HIST("hScaledFT0C_DPhi_JetPt_Corr_TTRef_RectrictedPhi"), scaledFT0C, dphi, jetPtCorr, weight); spectra.fill(HIST("hScaledFT0M_DPhi_JetPt_Corr_TTRef_RectrictedPhi"), scaledFT0M, dphi, jetPtCorr, weight); } @@ -671,8 +896,10 @@ struct RecoilJets { } template - void fillMCPHistograms(JCollision const& collision, Jets const& jets, - JParticles const& particles, float weight = 1.) + void fillHistogramsMCPartLevel(JCollision const& collision, + Jets const& jets, + JParticles const& particles, + float weight = 1.) { bool bSigEv = false; std::vector vPhiOfTT; @@ -693,13 +920,7 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0M_Rho_Part"), scaledFT0M, rho, weight); for (const auto& particle : particles) { - auto pdgParticle = pdg->GetParticle(particle.pdgCode()); - if (!pdgParticle) - continue; - - // Need charge and physical primary particles - bool bParticleNeutral = (static_cast(pdgParticle->Charge()) == 0); - if (bParticleNeutral || !particle.isPhysicalPrimary()) + if (skipParticle(particle)) continue; float particlePt = particle.pt(); @@ -708,12 +929,17 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0CPartPtEtaPhi"), scaledFT0C, particlePt, particle.eta(), particlePhi, weight); spectra.fill(HIST("hScaledFT0MPartPtEtaPhi"), scaledFT0M, particlePt, particle.eta(), particlePhi, weight); - if (bSigEv && (particlePt > ptTTsig->at(0) && particlePt < ptTTsig->at(1))) { + // Search for TT candidate + const auto ptTTsigMin = ptTTsig->at(0); + const auto ptTTsigMax = ptTTsig->at(1); + if (bSigEv && (particlePt > ptTTsigMin && particlePt < ptTTsigMax)) { vPhiOfTT.push_back(particlePhi); ++nTT; } - if (!bSigEv && (particlePt > ptTTref->at(0) && particlePt < ptTTref->at(1))) { + const auto ptTTrefMin = ptTTref->at(0); + const auto ptTTrefMax = ptTTref->at(1); + if (!bSigEv && (particlePt > ptTTrefMin && particlePt < ptTTrefMax)) { vPhiOfTT.push_back(particlePhi); ++nTT; } @@ -756,6 +982,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); auto [dphi, bRecoilJet] = isRecoilJet(jet, phiTT); @@ -768,7 +996,7 @@ struct RecoilJets { spectra.fill(HIST("hJetArea_JetPt_Rho_TTSig_Part"), jetArea, jetPt, rho, weight); - if (phiTT > phiRestrTTSelection->at(0) && phiTT < phiRestrTTSelection->at(1)) { + if (phiTT > phiMin && phiTT < phiMax) { spectra.fill(HIST("hScaledFT0C_DPhi_JetPt_Corr_TTSig_RectrictedPhi_Part"), scaledFT0C, dphi, jetPtCorr, weight); spectra.fill(HIST("hScaledFT0M_DPhi_JetPt_Corr_TTSig_RectrictedPhi_Part"), scaledFT0M, dphi, jetPtCorr, weight); } @@ -791,7 +1019,7 @@ struct RecoilJets { spectra.fill(HIST("hJetArea_JetPt_Rho_TTRef_Part"), jetArea, jetPt, rho, weight); - if (phiTT > phiRestrTTSelection->at(0) && phiTT < phiRestrTTSelection->at(1)) { + if (phiTT > phiMin && phiTT < phiMax) { spectra.fill(HIST("hScaledFT0C_DPhi_JetPt_Corr_TTRef_RectrictedPhi_Part"), scaledFT0C, dphi, jetPtCorr, weight); spectra.fill(HIST("hScaledFT0M_DPhi_JetPt_Corr_TTRef_RectrictedPhi_Part"), scaledFT0M, dphi, jetPtCorr, weight); } @@ -808,19 +1036,26 @@ struct RecoilJets { } } + //============================================================================= + // Construction of response matrix + //============================================================================= template void fillMatchedHistograms(JTracksTable const& tracks, - JetsBase const& jetsBase, JetsTag const& jetsTag, + JetsBase const& jetsBase, + JetsTag const& jetsTag, float weight = 1.) { std::vector vPhiOfTT; - double phiTTSig = 0.; + double phiTTSig = 0.0; for (const auto& track : tracks) { if (skipTrack(track)) continue; - if (track.pt() > ptTTsig->at(0) && track.pt() < ptTTsig->at(1)) { + // 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()); } } @@ -837,6 +1072,9 @@ struct RecoilJets { } } + //============================================================================= + // Event Activity analysis + //============================================================================= template void fillMultiplicityHistogramsOO(JCollision const& collision, float weight = 1.) @@ -894,7 +1132,7 @@ struct RecoilJets { } template - void fillMultiplicityHistogramsPartLevelMC(JCollisionMC const& collision, + void fillMultiplicityHistogramsMCPartLevel(JCollisionMC const& collision, float weight = 1.) { spectra.fill(HIST("hMultFT0APartLevel"), collision.multFT0A(), weight); @@ -908,9 +1146,14 @@ struct RecoilJets { spectra.fill(HIST("hScaleMultFT0MPartLevel"), getScaledFT0M(scaledFT0A, scaledFT0C), weight); } + //============================================================================= + // Event Activity QA analysis in OO collisions (raw and MC detector level (no weight)) + //============================================================================= template - void fillMultiplicityQA(Collision const& collision, BC const&, - ZDC const&, float weight = 1.) + void fillMultiplicityQA(Collision const& collision, + BC const&, + ZDC const&, + float weight = 1.) { int runNumber = collision.multRunNumber(); int fillNumber = getBinNumberOnYaxisForGivenRun(spectra.get(HIST("hScaledFT0CPerRunPerSetOfFlags")), runNumber) - 0.5; // Same for FT0M distrib. @@ -932,6 +1175,8 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0CPerRunPerSetOfFlags"), scaledFT0C, fillNumber, 0.5, weight); spectra.fill(HIST("hScaledFT0MPerRunPerSetOfFlags"), scaledFT0M, fillNumber, 0.5, weight); + spectra.fill(HIST("hEventSelectionCount"), 0.5); + bool isGoodZvtxFT0vsPV = collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV); if (isGoodZvtxFT0vsPV) { spectra.fill(HIST("hFT0APerRunPerSetOfFlags"), multFT0A, fillNumber, 1.5, weight); @@ -941,6 +1186,8 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0APerRunPerSetOfFlags"), scaledFT0A, fillNumber, 1.5, weight); spectra.fill(HIST("hScaledFT0CPerRunPerSetOfFlags"), scaledFT0C, fillNumber, 1.5, weight); spectra.fill(HIST("hScaledFT0MPerRunPerSetOfFlags"), scaledFT0M, fillNumber, 1.5, weight); + + spectra.fill(HIST("hEventSelectionCount"), 1.5); } bool isNoSameBunchPileup = collision.selection_bit(aod::evsel::kNoSameBunchPileup); @@ -952,9 +1199,13 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0APerRunPerSetOfFlags"), scaledFT0A, fillNumber, 2.5, weight); spectra.fill(HIST("hScaledFT0CPerRunPerSetOfFlags"), scaledFT0C, fillNumber, 2.5, weight); spectra.fill(HIST("hScaledFT0MPerRunPerSetOfFlags"), scaledFT0M, fillNumber, 2.5, weight); + + spectra.fill(HIST("hEventSelectionCount"), 2.5); } - if (isGoodZvtxFT0vsPV && isNoSameBunchPileup) { + bool isNoCollInTimeRangeStandard = collision.selection_bit(aod::evsel::kNoCollInTimeRangeStandard); + if (isNoCollInTimeRangeStandard) { + spectra.fill(HIST("hFT0APerRunPerSetOfFlags"), multFT0A, fillNumber, 3.5, weight); spectra.fill(HIST("hFT0CPerRunPerSetOfFlags"), multFT0C, fillNumber, 3.5, weight); spectra.fill(HIST("hFT0MPerRunPerSetOfFlags"), multFT0M, fillNumber, 3.5, weight); @@ -962,12 +1213,25 @@ struct RecoilJets { spectra.fill(HIST("hScaledFT0APerRunPerSetOfFlags"), scaledFT0A, fillNumber, 3.5, weight); spectra.fill(HIST("hScaledFT0CPerRunPerSetOfFlags"), scaledFT0C, fillNumber, 3.5, weight); spectra.fill(HIST("hScaledFT0MPerRunPerSetOfFlags"), scaledFT0M, fillNumber, 3.5, weight); - } else { - return; + + spectra.fill(HIST("hEventSelectionCount"), 3.5); } - // Investigate other EA variables + if (!(isGoodZvtxFT0vsPV && isNoSameBunchPileup & isNoCollInTimeRangeStandard)) + return; + + spectra.fill(HIST("hEventSelectionCount"), 4.5); // All accepted events after 4 flags cut + + spectra.fill(HIST("hFT0APerRunPerSetOfFlags"), multFT0A, fillNumber, 4.5, weight); + spectra.fill(HIST("hFT0CPerRunPerSetOfFlags"), multFT0C, fillNumber, 4.5, weight); + spectra.fill(HIST("hFT0MPerRunPerSetOfFlags"), multFT0M, fillNumber, 4.5, weight); + + spectra.fill(HIST("hScaledFT0APerRunPerSetOfFlags"), scaledFT0A, fillNumber, 4.5, weight); + spectra.fill(HIST("hScaledFT0CPerRunPerSetOfFlags"), scaledFT0C, fillNumber, 4.5, weight); + spectra.fill(HIST("hScaledFT0MPerRunPerSetOfFlags"), scaledFT0M, fillNumber, 4.5, weight); + //____________________________________________________________________________________ + // Investigate other EA variables // Multiplicity equalized for the vertex position with FT0 detector float multZeqFT0A = collision.multZeqFT0A(); @@ -1012,9 +1276,9 @@ struct RecoilJets { spectra.fill(HIST("hIsFT0SignalComeFromCollPerRun"), 0.5, fillNumber, weight); } else { spectra.fill(HIST("hIsFT0SignalComeFromCollPerRun"), 1.5, fillNumber, weight); - spectra.fill(HIST("hFT0AsignalWithoutBC"), multFT0A, fillNumber, weight); - spectra.fill(HIST("hFT0CsignalWithoutBC"), multFT0C, fillNumber, weight); - spectra.fill(HIST("hFT0MsignalWithoutBC"), multFT0M, fillNumber, weight); + spectra.fill(HIST("hScaledFT0AsignalWithoutBC"), scaledFT0A, fillNumber, weight); + spectra.fill(HIST("hScaledFT0CsignalWithoutBC"), scaledFT0C, fillNumber, weight); + spectra.fill(HIST("hScaledFT0MsignalWithoutBC"), scaledFT0M, fillNumber, weight); } if (collision.foundBCId() > 0) @@ -1023,6 +1287,9 @@ struct RecoilJets { spectra.fill(HIST("hIsFT0SignalComeFromCollPerRun"), 3.5, fillNumber, weight); } + //============================================================================= + // Di-hadron azimuthal correlation in raw and MC det. level (no weight) data + //============================================================================= template void fillLeadingAndAssociatedTracksTask(JCollision const& collision, JTracks const& tracks, float weight = 1.) { @@ -1074,12 +1341,16 @@ struct RecoilJets { } } - // Background fluctuations in MC part. level + //============================================================================= + // Estimation of bkgd fluctuations + //============================================================================= + + // Background fluctuations in raw data and MC det. level template - void fillBkgdFluctuationsRC(JCollision const& collision, - Jets const& jets, - JTracks const& tracks, - float weight = 1.) + void fillBkgdFluctuations(JCollision const& collision, + Jets const& jets, + JTracks const& tracks, + float weight = 1.) { //---------------------------------------------------------- float rho = collision.rho(); @@ -1111,8 +1382,10 @@ struct RecoilJets { randomConePt += track.pt(); } - // Search for TT candidate - if (track.pt() > ptTTsig->at(0) && track.pt() < ptTTsig->at(1)) { + // Search for TT_Sig candidate + const auto ptTTsigMin = ptTTsig->at(0); + const auto ptTTsigMax = ptTTsig->at(1); + if (track.pt() > ptTTsigMin && track.pt() < ptTTsigMax) { vCandForTT.emplace_back(index); } ++index; @@ -1172,7 +1445,7 @@ struct RecoilJets { //---------------------------------------------------------- // Place cone perpendicular to the leading jet (perpendicular cone) float perpConeEta = leadJetEta; - float perpConePhi = leadJetPhi + constants::math::PI / 2.; + float perpConePhi = leadJetPhi + constants::math::PIHalf; float perpConePt = 0.0; for (const auto& track : tracks) { @@ -1216,7 +1489,7 @@ struct RecoilJets { auto objTT = tracks.iteratorAt(vCandForTT[randIndexTrack]); // Skip events where TT is not a part of leading or subleading jets (mutlijet event, difficult to place RC and avoid hard jets) - if (IsTrackInJet(jets.iteratorAt(0), objTT) || IsTrackInJet(jets.iteratorAt(1), objTT)) { + if (isTrackInJet(jets.iteratorAt(0), objTT) || isTrackInJet(jets.iteratorAt(1), objTT)) { keepEventWithTT = true; } } @@ -1265,10 +1538,10 @@ struct RecoilJets { } template - void fillBkgdFluctuationsRCMCP(JCollision const& collision, - Jets const& jets, - JParticles const& particles, - float weight = 1.) + void fillBkgdFluctuationsMCPartLevel(JCollision const& collision, + Jets const& jets, + JParticles const& particles, + float weight = 1.) { //---------------------------------------------------------- float rho = collision.rho(); @@ -1289,13 +1562,7 @@ struct RecoilJets { uint64_t index = 0; for (const auto& particle : particles) { - auto pdgParticle = pdg->GetParticle(particle.pdgCode()); - if (!pdgParticle) - continue; - - // Need charge and physical primary particles - bool bParticleNeutral = (static_cast(pdgParticle->Charge()) == 0); - if (bParticleNeutral || !particle.isPhysicalPrimary()) + if (skipParticle(particle)) continue; float dEta = std::pow(randomConeEta - particle.eta(), 2); @@ -1306,14 +1573,16 @@ struct RecoilJets { randomConePt += particle.pt(); } - // Search for TT candidate - if (particle.pt() > ptTTsig->at(0) && particle.pt() < ptTTsig->at(1)) { + // Search for TT_Sig candidate + const auto ptTTsigMin = ptTTsig->at(0); + const auto ptTTsigMax = ptTTsig->at(1); + if (particle.pt() > ptTTsigMin && particle.pt() < ptTTsigMax) { vCandForTT.emplace_back(index); } ++index; } - spectra.fill(HIST("hScaledFT0C_deltaPtRandomCone"), scaledFT0C, randomConePt - areaRC * rho, weight); - spectra.fill(HIST("hScaledFT0M_deltaPtRandomCone"), scaledFT0M, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0C_deltaPtRandomCone_PartLevel"), scaledFT0C, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0M_deltaPtRandomCone_PartLevel"), scaledFT0M, randomConePt - areaRC * rho, weight); //---------------------------------------------------------- // Avoid leading jet (JE jet reconstruction sorts jets by pT) @@ -1349,13 +1618,7 @@ struct RecoilJets { if (isTherePlaceForRC) { randomConePt = 0.0; for (const auto& particle : particles) { - auto pdgParticle = pdg->GetParticle(particle.pdgCode()); - if (!pdgParticle) - continue; - - // Need charge and physical primary particles - bool bParticleNeutral = (static_cast(pdgParticle->Charge()) == 0); - if (bParticleNeutral || !particle.isPhysicalPrimary()) + if (skipParticle(particle)) continue; float dEta = std::pow(randomConeEta - particle.eta(), 2); @@ -1366,24 +1629,18 @@ struct RecoilJets { randomConePt += particle.pt(); } } - spectra.fill(HIST("hScaledFT0C_deltaPtRandomConeAvoidLeadJet"), scaledFT0C, randomConePt - areaRC * rho, weight); - spectra.fill(HIST("hScaledFT0M_deltaPtRandomConeAvoidLeadJet"), scaledFT0M, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0C_deltaPtRandomConeAvoidLeadJet_PartLevel"), scaledFT0C, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0M_deltaPtRandomConeAvoidLeadJet_PartLevel"), scaledFT0M, randomConePt - areaRC * rho, weight); } //---------------------------------------------------------- // Place cone perpendicular to the leading jet (perpendicular cone) float perpConeEta = leadJetEta; - float perpConePhi = leadJetPhi + constants::math::PI / 2.; + float perpConePhi = leadJetPhi + constants::math::PIHalf; float perpConePt = 0.0; for (const auto& particle : particles) { - auto pdgParticle = pdg->GetParticle(particle.pdgCode()); - if (!pdgParticle) - continue; - - // Need charge and physical primary particles - bool bParticleNeutral = (static_cast(pdgParticle->Charge()) == 0); - if (bParticleNeutral || !particle.isPhysicalPrimary()) + if (skipParticle(particle)) continue; float dEta = std::pow(perpConeEta - particle.eta(), 2); @@ -1394,8 +1651,8 @@ struct RecoilJets { perpConePt += particle.pt(); } } - spectra.fill(HIST("hScaledFT0C_deltaPtPerpConeAvoidLeadJet"), scaledFT0C, perpConePt - areaRC * rho, weight); - spectra.fill(HIST("hScaledFT0M_deltaPtPerpConeAvoidLeadJet"), scaledFT0M, perpConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0C_deltaPtPerpConeAvoidLeadJet_PartLevel"), scaledFT0C, perpConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0M_deltaPtPerpConeAvoidLeadJet_PartLevel"), scaledFT0M, perpConePt - areaRC * rho, weight); } //---------------------------------------------------------- @@ -1423,7 +1680,7 @@ struct RecoilJets { auto objTT = particles.iteratorAt(vCandForTT[randIndexParticle]); // Skip events where TT is not a part of leading or subleading jets (mutlijet event, difficult to place RC and avoid hard jets) - if (IsTrackInJet(jets.iteratorAt(0), objTT) || IsTrackInJet(jets.iteratorAt(1), objTT)) { + if (isTrackInJet(jets.iteratorAt(0), objTT) || isTrackInJet(jets.iteratorAt(1), objTT)) { keepEventWithTT = true; } } @@ -1449,13 +1706,7 @@ struct RecoilJets { if (isTherePlaceForRC) { randomConePt = 0.0; for (const auto& particle : particles) { - auto pdgParticle = pdg->GetParticle(particle.pdgCode()); - if (!pdgParticle) - continue; - - // Need charge and physical primary particles - bool bParticleNeutral = (static_cast(pdgParticle->Charge()) == 0); - if (bParticleNeutral || !particle.isPhysicalPrimary()) + if (skipParticle(particle)) continue; float dEta = std::pow(randomConeEta - particle.eta(), 2); @@ -1466,20 +1717,25 @@ struct RecoilJets { randomConePt += particle.pt(); } } - spectra.fill(HIST("hScaledFT0C_deltaPtRandomConeAvoidLeadAndSubleadJet"), scaledFT0C, randomConePt - areaRC * rho, weight); - spectra.fill(HIST("hScaledFT0M_deltaPtRandomConeAvoidLeadAndSubleadJet"), scaledFT0M, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0C_deltaPtRandomConeAvoidLeadAndSubleadJet_PartLevel"), scaledFT0C, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0M_deltaPtRandomConeAvoidLeadAndSubleadJet_PartLevel"), scaledFT0M, randomConePt - areaRC * rho, weight); if (keepEventWithTT) { - spectra.fill(HIST("hScaledFT0C_deltaPtRandomConeInEventTTSig"), scaledFT0C, randomConePt - areaRC * rho, weight); - spectra.fill(HIST("hScaledFT0M_deltaPtRandomConeInEventTTSig"), scaledFT0M, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0C_deltaPtRandomConeInEventTTSig_PartLevel"), scaledFT0C, randomConePt - areaRC * rho, weight); + spectra.fill(HIST("hScaledFT0M_deltaPtRandomConeInEventTTSig_PartLevel"), scaledFT0M, randomConePt - areaRC * rho, weight); } } } } - //------------------------------------------------------------------------------ - // Process functions - void processData(FilteredColl const& collision, FilteredTracks const& tracks, + //----------------------------------------------------------------------------- + // Block of Process Functions + + //============================================================================= + // Recoil jet analysis + //============================================================================= + void processData(FilteredColl const& collision, + FilteredTracks const& tracks, FilteredJets const& jets) { spectra.fill(HIST("hEventSelectionCount"), 0.5); @@ -1493,6 +1749,7 @@ struct RecoilJets { } PROCESS_SWITCH(RecoilJets, processData, "process raw data", true); + //____________________ void processMCDetLevel(FilteredColl const& collision, FilteredTracks const& tracks, FilteredJetsDetLevel const& jets) @@ -1503,16 +1760,12 @@ struct RecoilJets { spectra.fill(HIST("hEventSelectionCount"), 1.5); - if (skipMBGapEvent(collision)) { - spectra.fill(HIST("hEventSelectionCount"), 2.5); - return; - } - - spectra.fill(HIST("hEventSelectionCount"), 5.5); // number of events selected for analysis + spectra.fill(HIST("hEventSelectionCount"), 4.5); // number of events selected for analysis fillHistograms(collision, jets, tracks); } - PROCESS_SWITCH(RecoilJets, processMCDetLevel, "process MC detector level data (no weight)", false); + PROCESS_SWITCH(RecoilJets, processMCDetLevel, "process MC det. level data (no weight)", false); + //____________________________ void processMCDetLevelWeighted(FilteredCollDetLevelGetWeight const& collision, aod::JetMcCollisions const&, FilteredTracks const& tracks, @@ -1524,50 +1777,47 @@ struct RecoilJets { spectra.fill(HIST("hEventSelectionCount"), 1.5); - if (skipMBGapEvent(collision)) { - spectra.fill(HIST("hEventSelectionCount"), 2.5); - return; - } - if (collision.isOutlier()) { - spectra.fill(HIST("hEventSelectionCount"), 3.5); + spectra.fill(HIST("hEventSelectionCount"), 2.5); return; } if (!collision.has_mcCollision()) { - spectra.fill(HIST("hEventSelectionCount"), 4.5); + spectra.fill(HIST("hEventSelectionCount"), 3.5); return; } - spectra.fill(HIST("hEventSelectionCount"), 5.5); // number of events selected for analysis + spectra.fill(HIST("hEventSelectionCount"), 4.5); // number of events selected for analysis auto weight = collision.mcCollision().weight(); fillHistograms(collision, jets, tracks, weight); } - PROCESS_SWITCH(RecoilJets, processMCDetLevelWeighted, "process MC detector level data (weighted)", false); + PROCESS_SWITCH(RecoilJets, processMCDetLevelWeighted, "process MC det. level data (weighted)", false); - void processMCPartLevel(FilteredCollPartLevel const& collision, + //_____________________ + void processMCPartLevel(FilteredCollPartLevelMB const& collision, FilteredParticles const& particles, FilteredJetsPartLevel const& jets) { spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5); - if (skipMBGapEvent(collision)) { + if (skipMCEvent(collision)) { spectra.fill(HIST("hEventSelectionCountPartLevel"), 1.5); return; } spectra.fill(HIST("hEventSelectionCountPartLevel"), 3.5); // number of events selected for analysis - fillMCPHistograms(collision, jets, particles); + fillHistogramsMCPartLevel(collision, jets, particles); } - PROCESS_SWITCH(RecoilJets, processMCPartLevel, "process MC particle level data (no weight)", false); + PROCESS_SWITCH(RecoilJets, processMCPartLevel, "process MC part. level data (no weight)", false); + //_____________________________ void processMCPartLevelWeighted(FilteredCollPartLevel const& collision, FilteredParticles const& particles, FilteredJetsPartLevel const& jets) { spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5); - if (skipMBGapEvent(collision)) { + if (skipMCEvent(collision)) { spectra.fill(HIST("hEventSelectionCountPartLevel"), 1.5); return; } @@ -1581,17 +1831,20 @@ struct RecoilJets { auto weight = collision.weight(); spectra.fill(HIST("ptHat"), collision.ptHard(), weight); - fillMCPHistograms(collision, jets, particles, weight); + fillHistogramsMCPartLevel(collision, jets, particles, weight); } - PROCESS_SWITCH(RecoilJets, processMCPartLevelWeighted, "process MC particle level data (weighted)", false); + PROCESS_SWITCH(RecoilJets, processMCPartLevelWeighted, "process MC part. level data (weighted)", false); - void processJetsMatched(FilteredCollDetLevelGetWeight const& collision, + //============================================================================= + // Construction of response matrix + //============================================================================= + void processJetsMatched(soa::Filtered>::iterator const& collision, aod::JetMcCollisions const&, FilteredTracks const& tracks, FilteredMatchedJetsDetLevel const& mcdjets, FilteredMatchedJetsPartLevel const& mcpjets) { - if (skipEvent(collision) || skipMBGapEvent(collision) || collision.isOutlier()) + if (skipEvent(collision)) return; auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); @@ -1600,13 +1853,14 @@ struct RecoilJets { } PROCESS_SWITCH(RecoilJets, processJetsMatched, "process matching of MC jets (no weight)", false); + //_____________________________ void processJetsMatchedWeighted(FilteredCollDetLevelGetWeight const& collision, aod::JetMcCollisions const&, FilteredTracks const& tracks, FilteredMatchedJetsDetLevel const& mcdjets, FilteredMatchedJetsPartLevel const& mcpjets) { - if (skipEvent(collision) || skipMBGapEvent(collision) || collision.isOutlier()) + if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) return; auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); @@ -1616,16 +1870,21 @@ struct RecoilJets { } PROCESS_SWITCH(RecoilJets, processJetsMatchedWeighted, "process matching of MC jets (weighted)", false); - void processMultiplicityOO(FilteredEventMultiplicity const& collision) + //============================================================================= + // Event Activity analysis in OO collisions (raw and MC detector level (no weight)) + //============================================================================= + void processEventActivityOO(FilteredEventMultiplicity const& collision) { if (skipEvent(collision)) return; fillMultiplicityHistogramsOO(collision); } - PROCESS_SWITCH(RecoilJets, processMultiplicityOO, "process multiplicity for OO collisions and MC detector level (no weight)", false); + PROCESS_SWITCH(RecoilJets, processEventActivityOO, "process event activity in OO collisions and MC det. level (no weight)", false); - void processMultiplicityMCDetLevelWeightedOO(FilteredEventMultiplicityDetLevelGetWeight const& collision) + //___________________________________________ + void processEventActivityMCDetLevelWeightedOO(FilteredEventMultiplicityDetLevelGetWeight const& collision, + aod::JetMcCollisions const&) { if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) return; @@ -1633,30 +1892,37 @@ struct RecoilJets { auto weight = collision.mcCollision().weight(); fillMultiplicityHistogramsOO(collision, weight); } - PROCESS_SWITCH(RecoilJets, processMultiplicityMCDetLevelWeightedOO, "process multiplicity for MC detector level OO collisions (weighted)", false); + PROCESS_SWITCH(RecoilJets, processEventActivityMCDetLevelWeightedOO, "process event activity in MC det. level OO collisions (weighted)", false); - void processMultiplicityPartLevelMC(FilteredEventMultiplicityPartLevel const& collision) + //============================================================================= + // Event Activity analysis in OO and pp collisions at Particle level + //============================================================================= + void processEventActivityMCPartLevel(FilteredEventMultiplicityPartLevelMB const& collision) { - if (skipMBGapEvent(collision)) + if (skipMCEvent(collision)) return; - fillMultiplicityHistogramsPartLevelMC(collision); + fillMultiplicityHistogramsMCPartLevel(collision); } - PROCESS_SWITCH(RecoilJets, processMultiplicityPartLevelMC, "process multiplicity for MC particle level events (no weight)", false); + PROCESS_SWITCH(RecoilJets, processEventActivityMCPartLevel, "process event activity in MC part. level events (no weight)", false); - void processMultiplicityPartLevelMCWeighted(FilteredEventMultiplicityPartLevel const& collision) + //__________________________________________ + void processEventActivityMCPartLevelWeighted(FilteredEventMultiplicityPartLevel const& collision) { - if (skipMBGapEvent(collision) || collision.isOutlier()) + if (skipMCEvent(collision) || collision.isOutlier()) return; auto weight = collision.weight(); - fillMultiplicityHistogramsPartLevelMC(collision, weight); + fillMultiplicityHistogramsMCPartLevel(collision, weight); } - PROCESS_SWITCH(RecoilJets, processMultiplicityPartLevelMCWeighted, "process multiplicity for MC particle level events (weighted)", false); - - void processMultiplicityQA(ColEvSelEA const& collision, - BCsRun3 const& BCs, - aod::Zdcs const& ZDCs) + PROCESS_SWITCH(RecoilJets, processEventActivityMCPartLevelWeighted, "process event activity in MC part. level events (weighted)", false); + + //============================================================================= + // Event Activity QA analysis in OO collisions (raw and MC detector level (no weight)) + //============================================================================= + void processEventActivityQA(ColEvSelEA const& collision, + BCsRun3 const& BCs, + aod::Zdcs const& ZDCs) { // Base flag for event selection if (!collision.sel8()) @@ -1664,50 +1930,84 @@ struct RecoilJets { fillMultiplicityQA(collision, BCs, ZDCs); } - PROCESS_SWITCH(RecoilJets, processMultiplicityQA, "process function for EA QA purposes", false); + PROCESS_SWITCH(RecoilJets, processEventActivityQA, "process function for EA QA purposes in raw and MC det. level (no weight) data", false); + //============================================================================= + // Di-hadron azimuthal correlation in raw and MC det. level (no weight) data + //============================================================================= void processLeadingAndAssociatedTracksTask(soa::Filtered::iterator const& collision, - soa::Filtered const& tracks) + FilteredTracks const& tracks) { if (skipEvent(collision)) return; fillLeadingAndAssociatedTracksTask(collision, tracks); } - PROCESS_SWITCH(RecoilJets, processLeadingAndAssociatedTracksTask, "process function for correlation between leading and associated tracks", false); + PROCESS_SWITCH(RecoilJets, processLeadingAndAssociatedTracksTask, "process di-hadron azimuthal correlation in raw and MC det. level (no weight) data", false); + + //============================================================================= + // Estimation of bkgd fluctuations + //============================================================================= + void processBkgdFluctuations(FilteredColl const& collision, + FilteredTracks const& tracks, + FilteredJets const& jets) + { + if (skipEvent(collision)) + return; - void processBkgdFluctuationsRC(FilteredColl const& collision, - FilteredTracks const& tracks, - FilteredJets const& jets) + fillBkgdFluctuations(collision, jets, tracks); + } + PROCESS_SWITCH(RecoilJets, processBkgdFluctuations, "process raw data to estimate bkgd fluctuations", false); + + //____________________________________ + void processBkgdFluctuationsMCDetLevel(FilteredColl const& collision, + FilteredTracks const& tracks, + FilteredJetsDetLevel const& jets) { if (skipEvent(collision)) return; - fillBkgdFluctuationsRC(collision, jets, tracks); + fillBkgdFluctuations(collision, jets, tracks); + } + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevel, "process MC det. level (no weight) data to estimate bkgd fluctuations", false); + + //____________________________________________ + void processBkgdFluctuationsMCDetLevelWeighted(FilteredCollDetLevelGetWeight const& collision, + aod::JetMcCollisions const&, + FilteredTracks const& tracks, + FilteredJetsDetLevel const& jets) + { + if (skipEvent(collision) || collision.isOutlier() || !collision.has_mcCollision()) + return; + + auto weight = collision.mcCollision().weight(); + fillBkgdFluctuations(collision, jets, tracks, weight); } - PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsRC, "process data to estimate bkgd fluctuations using random cone (RC)", false); + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCDetLevelWeighted, "process MC det. level (weighted) data to estimate bkgd fluctuations", false); - void processBkgdFluctuationsRCMCP(FilteredCollPartLevel const& collision, - FilteredParticles const& particles, - FilteredJetsPartLevel const& jets) + //_____________________________________ + void processBkgdFluctuationsMCPartLevel(FilteredCollPartLevelMB const& collision, + FilteredParticles const& particles, + FilteredJetsPartLevel const& jets) { - if (skipMBGapEvent(collision)) + if (skipMCEvent(collision)) return; - fillBkgdFluctuationsRCMCP(collision, jets, particles); + fillBkgdFluctuationsMCPartLevel(collision, jets, particles); } - PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsRCMCP, "process data to estimate bkgd fluctuations using random cone (RC) in MC Particle Level", false); + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevel, "process MC part. level (no weight) data to estimate bkgd fluctuations", false); - void processBkgdFluctuationsRCMCPWeighted(FilteredCollPartLevel const& collision, - FilteredParticles const& particles, - FilteredJetsPartLevel const& jets) + //_____________________________________________ + void processBkgdFluctuationsMCPartLevelWeighted(FilteredCollPartLevel const& collision, + FilteredParticles const& particles, + FilteredJetsPartLevel const& jets) { - if (skipMBGapEvent(collision) || collision.isOutlier()) + if (skipMCEvent(collision) || collision.isOutlier()) return; auto weight = collision.weight(); - fillBkgdFluctuationsRCMCP(collision, jets, particles, weight); + fillBkgdFluctuationsMCPartLevel(collision, jets, particles, weight); } - PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsRCMCPWeighted, "process data to estimate bkgd fluctuations using random cone (RC) in MC Particle Level weighted", false); + PROCESS_SWITCH(RecoilJets, processBkgdFluctuationsMCPartLevelWeighted, "process MC part. level (weighted) data to estimate bkgd fluctuations", false); //------------------------------------------------------------------------------ // Auxiliary functions @@ -1715,13 +2015,13 @@ struct RecoilJets { bool skipEvent(const Collision& coll) { /// \brief: trigger cut is needed for pp data - return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); + return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits, skipMBGapEvents, applyRCTSelections, rctLabel, rejectLimitedAcceptanceRct, requireZDCRct) || !jetderiveddatautilities::selectTrigger(coll, triggerMaskBits); } template - bool skipMBGapEvent(const Collision& coll) + bool skipMCEvent(const Collision& coll) { - return skipMBGapEvents && coll.getSubGeneratorId() == jetderiveddatautilities::JCollisionSubGeneratorId::mbGap; + return !jetderiveddatautilities::selectMcCollision(coll, skipMBGapEvents, applyRCTSelections, rctLabel, rejectLimitedAcceptanceRct, requireZDCRct); } template @@ -1730,6 +2030,17 @@ struct RecoilJets { return !jetderiveddatautilities::selectTrack(track, trackSelection); } + template + bool skipParticle(const Particle& particle) + { + auto* pdgParticle = pdg->GetParticle(particle.pdgCode()); + if (!pdgParticle) { + return true; + } + const bool bParticleNeutral = (static_cast(pdgParticle->Charge()) == 0); + return bParticleNeutral || !particle.isPhysicalPrimary(); + } + template std::tuple isRecoilJet(const Jet& jet, double phiTT) { @@ -1767,7 +2078,7 @@ struct RecoilJets { } template - bool IsTrackInJet(Jet const& jet, Track const& track) + bool isTrackInJet(Jet const& jet, Track const& track) { for (auto const& constituentId : jet.tracksIds()) { if (constituentId == track.globalIndex()) { @@ -1778,7 +2089,7 @@ struct RecoilJets { } template - int getBinNumberOnYaxisForGivenRun(std::shared_ptr histogram, int runNumber) + int getBinNumberOnYaxisForGivenRun(const std::shared_ptr& histogram, int runNumber) { int nBins = histogram->GetYaxis()->GetNbins(); int binNumber = -1; @@ -1853,6 +2164,27 @@ struct RecoilJets { } } } + + template + void setBinLablesYZaxes(const std::shared_ptr& histPointer, + const std::vector& yAxis, + const std::vector& zAxis) + { + const int nRunsOO = yAxis.size(); + const int nEvSelFlags = zAxis.size(); + for (int iRun = 0; iRun < nRunsOO; ++iRun) { + histPointer->GetYaxis()->SetBinLabel(iRun + 1, yAxis[iRun]); + } + + const int dimOf2DHist = 2; + bool isHist2D = histPointer->GetDimension() == dimOf2DHist; + if (isHist2D) + return; + + for (int iFlag = 0; iFlag < nEvSelFlags; ++iFlag) { + histPointer->GetZaxis()->SetBinLabel(iFlag + 1, zAxis[iFlag]); + } + } }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 4747945dd0f9cf19e2500603188a7c1d48c0366a Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Thu, 15 Jan 2026 15:26:25 +0100 Subject: [PATCH 2/4] Clang fix --- PWGJE/Tasks/recoilJets.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index 2f1743bafd3..d8f30e1720e 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -161,7 +161,7 @@ struct RecoilJets { template struct AxisDesc { AxisDesc(const char* label_, const AxisObject& axis_, const std::string& axisName_ = "") - : label(label_), axis(axis_), axisName(axisName_) {}; + : label(label_), axis(axis_), axisName(axisName_){}; const char* label; // "FT0C" / "FT0M" const AxisObject& axis; // AxisSpec or ConfigurableAxis From cd515792089c14b2e6075a93dbf884214bc573c2 Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Thu, 15 Jan 2026 15:58:22 +0100 Subject: [PATCH 3/4] [PWGJE] Fix megalinter --- PWGJE/Tasks/recoilJets.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index d8f30e1720e..39fc10859d4 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -161,7 +161,7 @@ struct RecoilJets { template struct AxisDesc { AxisDesc(const char* label_, const AxisObject& axis_, const std::string& axisName_ = "") - : label(label_), axis(axis_), axisName(axisName_){}; + : label(label_), axis(axis_), axisName(axisName_){} const char* label; // "FT0C" / "FT0M" const AxisObject& axis; // AxisSpec or ConfigurableAxis From 8aadd54216ab7e19983ddce395172543e9a21456 Mon Sep 17 00:00:00 2001 From: KotliarovAr Date: Thu, 15 Jan 2026 16:47:58 +0100 Subject: [PATCH 4/4] [PWGJE] Fix clang --- PWGJE/Tasks/recoilJets.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGJE/Tasks/recoilJets.cxx b/PWGJE/Tasks/recoilJets.cxx index 39fc10859d4..031e2c9f17e 100644 --- a/PWGJE/Tasks/recoilJets.cxx +++ b/PWGJE/Tasks/recoilJets.cxx @@ -161,7 +161,7 @@ struct RecoilJets { template struct AxisDesc { AxisDesc(const char* label_, const AxisObject& axis_, const std::string& axisName_ = "") - : label(label_), axis(axis_), axisName(axisName_){} + : label(label_), axis(axis_), axisName(axisName_) {} const char* label; // "FT0C" / "FT0M" const AxisObject& axis; // AxisSpec or ConfigurableAxis