From e4c372b82f95a29ad710cf75ae5ba7af634a11f2 Mon Sep 17 00:00:00 2001 From: fkrizek Date: Tue, 26 May 2026 10:29:16 +0200 Subject: [PATCH 1/5] New code for hadronjet correlations of Jan Janis --- PWGJE/Tasks/CMakeLists.txt | 4 + PWGJE/Tasks/trackJetSpectra.cxx | 874 ++++++++++++++++++++++++++++++++ 2 files changed, 878 insertions(+) create mode 100644 PWGJE/Tasks/trackJetSpectra.cxx diff --git a/PWGJE/Tasks/CMakeLists.txt b/PWGJE/Tasks/CMakeLists.txt index 0475580147f..f19bbfbd5d1 100644 --- a/PWGJE/Tasks/CMakeLists.txt +++ b/PWGJE/Tasks/CMakeLists.txt @@ -325,6 +325,10 @@ if(FastJet_FOUND) SOURCES recoilJets.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(track-jet-spectra + SOURCES trackJetSpectra.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(jet-nsubjettiness SOURCES nsubjettiness.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::PWGJECore O2Physics::AnalysisCore diff --git a/PWGJE/Tasks/trackJetSpectra.cxx b/PWGJE/Tasks/trackJetSpectra.cxx new file mode 100644 index 00000000000..7e0555c091d --- /dev/null +++ b/PWGJE/Tasks/trackJetSpectra.cxx @@ -0,0 +1,874 @@ +// Copyright 2020-2022 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. + +/// \author Kotliarov Artem +/// \file trackJetSpectra.cxx +/// \brief track and jet analysis + +#include "PWGJE/Core/JetDerivedDataUtilities.h" +#include "PWGJE/DataModel/Jet.h" +#include "PWGJE/DataModel/JetReducedData.h" +#include "PWGJE/DataModel/JetSubtraction.h" + +#include "Common/Core/RecoDecay.h" +#include "Common/DataModel/Multiplicity.h" + +#include "CommonConstants/MathConstants.h" +#include "Framework/ASoA.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include +#include +#include +#include +#include +#include + +#include "TRandom3.h" +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +using FilteredColl = soa::Filtered>::iterator; +using FilteredEventMultiplicity = soa::Filtered>::iterator; + +using FilteredJetsDetLevel = soa::Filtered>; +using FilteredJetsPartLevel = soa::Filtered>; + +using FilteredCollDetLevelGetWeight = soa::Filtered>::iterator; + +using FilteredCollPartLevel = soa::Filtered>::iterator; +using FilteredParticles = soa::Filtered; +using FilteredJetsPartLevel = soa::Filtered>; + +using FilteredTracks = soa::Filtered; +using FilteredMatchedJetsDetLevel = soa::Filtered>; +using FilteredMatchedJetsPartLevel = soa::Filtered>; + +struct TrackJetSpectra { + + // List of configurable parameters + Configurable evSel{"evSel", "sel8", "Choose event selection"}; + Configurable trkSel{"trkSel", "globalTracks", "Set track selection"}; + Configurable vertexZCut{"vertexZCut", 10., "Accepted z-vertex range"}; + + Configurable trkPtMin{"trkPtMin", 0.15, "Minimum pT of acceptanced tracks"}; + Configurable trkPtMax{"trkPtMax", 100., "Maximum pT of acceptanced tracks"}; + + Configurable trkEtaCut{"trkEtaCut", 0.9, "Eta acceptance of TPC"}; + Configurable jetR{"jetR", 0.4, "Jet cone radius"}; + + Configurable SignalTriggerMin{"STriggerMin", 15., "Minimal Signal Trigger Track pT"}; + Configurable SignalTriggerMax{"STriggerMax", 50., "Maximal Signal Trigger Track pT"}; + Configurable ReferenceTriggerMin{"RTriggerMin", 5., "Minimal Reference Trigger Track pT"}; + Configurable ReferenceTriggerMax{"RTriggerMax", 7., "Maximal Reference Trigger Track pT"}; + Configurable SigToRefFraction{"Fraction", 0.1, ""}; + Configurable DPhiCut{"DPhiCut", 0.6, ""}; + // List of configurable parameters for histograms + Configurable histJetPt{"histJetPt", 150, "Maximum value of jet pT shown in histograms"}; + + Configurable meanFT0A{"meanFT0A", -1., "Mean value of FT0A signal"}; + Configurable meanFT0C{"meanFT0C", -1., "Mean value of FT0C signal"}; + + //------------------------------------------------------------ + + TRandom3* rand = new TRandom3(0); + // Declare filter on collision Z vertex + Filter collisionFilter = nabs(aod::jcollision::posZ) < vertexZCut; + Filter collisionFilterMC = nabs(aod::jmccollision::posZ) < vertexZCut; + + // Declare filters on accepted tracks and MC particles (settings for jet reco are provided in the jet finder wagon) + Filter trackFilter = aod::jtrack::pt > trkPtMin && aod::jtrack::pt < trkPtMax && nabs(aod::jtrack::eta) < trkEtaCut; + Filter partFilter = nabs(aod::jmcparticle::eta) < trkEtaCut; + + // Declare filter on jets + Filter jetRadiusFilter = aod::jet::r == nround(jetR.node() * 100.); + + HistogramRegistry spectra; + + std::vector eventSelectionBits; + int trackSelection = -1; + + Service pdg; + Preslice partJetsPerCollision = aod::jet::mcCollisionId; + + void init(InitContext const&) + { + // Initialize histogram axes + AxisSpec pT{histJetPt+20, -20.0, histJetPt * 1., "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec phiAngle{40, 0.0, constants::math::TwoPI, "#it{#varphi} (rad)"}; + AxisSpec etaTracks{100, -1.0, 1.0, "#it{#eta}_{trk}"}; + AxisSpec etaJets{100, -0.6, 0.6, "#it{#eta}_{jet}"}; + + + AxisSpec jetArea{50, 0.0, 3., "Area_{jet}"}; + AxisSpec rho{50, 0.0, 50., "#it{#rho}"}; + AxisSpec rhoArea{60, 0.0, 60., "#it{#rho} #times Area_{jet}"}; + + // Convert configurable strings to std::string + std::string evSelToString = static_cast(evSel); + std::string trkSelToString = static_cast(trkSel); + + eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(evSelToString); + trackSelection = jetderiveddatautilities::initialiseTrackSelection(trkSelToString); + + /* + How to add histograms: + + spectra.add("histogram_name", "Histogram title", histogram_type (kTH1F/kTH1D and so on), {axis1, axis2, ...}); + where axis is definened as: + + AxisSpec axis_name{nbins, min_value, max_value, "axis_title"}; + or + {nbins, min_value, max_value, "axis_title"} + */ + + if(doprocessFilteredCollisions || doprocessCollisions) //FK AKTUALIZOVAT PODLE PROCESS FUNKCI + { + // Event selection + spectra.add("hEventSelectionCount", "Count # of events in the analysis", kTH1F, {{3, 0.0, 3.}}); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(1, "Total # of events w/o cuts"); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(2, Form("# of events after sel. %s", evSelToString.data())); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(3, "# of events after z cut"); //? + + // Z coordinate of collision vertex + spectra.add("hVertexZ_NoCut", "z vertex of collisions w/o cut", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); + spectra.add("hVertexZ_Cut", "z vertex of collisions w. cut", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); + spectra.add("hVertexZ_EventFiltering", "z vertex of collisions w. event filtering", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); + } + + // Disitribution of tracks + if(doprocessTracks||doprocessJets) //FK AKTUALIZOVAT PODLE PROCESS FUNKCI I S OHLEDEM NA PARTICLE LEVEL + { + spectra.add("hPocetTracku", "Pocet", kTH1F, {{1000, 0., 1000., "Pocet Eventu"}}); + spectra.add("hPocetSignalTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); + spectra.add("hPocetReferenceTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); + spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); + spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); + + spectra.add("hTrackPtPhi", "#it{p}_{T} vs. #varphi distribution of tracks", kTH2F, {pT, phiAngle}); + spectra.add("hTrackPtEta", "#it{p}_{T} vs. #eta distribution of tracks", kTH2F, {pT, etaTracks}); + + spectra.add("hTrackPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of tracks", kTH3F, {pT, phiAngle, etaTracks}); + + // Distribution of jets + spectra.add("hJetPt", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + spectra.add("hJetPhi", "#varphi distribution of jets", kTH1F, {phiAngle}); + spectra.add("hJetEta", "#eta distribution of jets", kTH1F, {etaJets}); + + spectra.add("hJetPtPhi", "#it{p}_{T} vs. #varphi distribution of jets", kTH2F, {pT, phiAngle}); + spectra.add("hJetPtEta", "#it{p}_{T} vs. #eta distribution of jets", kTH2F, {pT, etaJets}); + + spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); + + 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("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + + spectra.add("hRho", "distribution of rho", kTH1F, {rho}); + spectra.add("hjetArea", "distribution of jet area", kTH1F, {jetArea}); + + spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); + spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); + + spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); + spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); + + spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH1F, {pT}); + spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH1F, {pT}); + + spectra.add("hEventSelectionCountPartLevel", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); + spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + + spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); + + spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + + spectra.add("hTTCountPartLevel", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT MCP"}}); + spectra.add("hTTCountData", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT Data"}}); + + spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + + spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); + + spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); + spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); + + + + } + } + + //------------------------------------------------------------------------------ + /* + In jet group, we do not use general information about collisions and tracks. We simply do not + need all that information for jet finding and jet analysis. Therefore, we use ASoA tables with + reduced information (aod::JetCollisions and aod::JetTracks). These tables are filled here: https://github.com/AliceO2Group/O2Physics/blob/4e284820d3b2f94327f0b71088c127decd74e8f9/PWGJE/TableProducer/derivedDataProducer.cxx + + Content of the tables can be found here: https://github.com/AliceO2Group/O2Physics/blob/cbc6e1f2eda0de5c8b00f64818e76eaa7e914232/PWGJE/DataModel/JetReducedData.h#L67 + + + + */ + + + + + template + void fillHistograms(Collision const& collision, Jets const& jets, + Tracks const& tracks) + + { + + if (skipEvent(collision)){ + return; + } + + std::vector SigTrackPhi; + std::vector SigTrackEta; + std::vector RefTrackPhi; + std::vector RefTrackEta; + + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + //float multZNA = collision.multZNA(); + //float multZNC = collision.multZNC(); + + spectra.fill(HIST("hMultFT0A"), multFT0A); + spectra.fill(HIST("hMultFT0C"), multFT0C); + + + float jetR2 = jetR*jetR; + float rho = collision.rho(); + + spectra.fill(HIST("hRho"), rho); + + int i = 0; + for (const auto& track : tracks) + { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + i++; + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); + + spectra.fill(HIST("hTrackPt"), trackPt); + spectra.fill(HIST("hTrackPhi"), trackPhi); + spectra.fill(HIST("hTrackEta"), trackEta); + + spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); + spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); + + spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); + + + + if((SignalTriggerMin<=trackPt)&&(trackPt<=SignalTriggerMax)){ + SigTrackPhi.push_back(trackPhi); + SigTrackEta.push_back(trackEta); + } + + if((ReferenceTriggerMin<=trackPt)&&(trackPt<=ReferenceTriggerMax)){ + RefTrackPhi.push_back(trackPhi); + RefTrackEta.push_back(trackEta); + } + + + } + + spectra.fill(HIST("hRhovsNTracks"), i, rho); + + float PerpConePhi = -99; + float PhiTT = -999; //FK PSAT DO KODU KOMENTARE + float EtaTT = -999; + float rnd = rand->Rndm(); + bool analyzeSignal =0; + + if (rnd < SigToRefFraction){ + analyzeSignal=1; + + } + + if (analyzeSignal==0&&RefTrackPhi.size()>0){ + + int ii = rand->Integer(RefTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 0.5); + spectra.fill(HIST("hPocetReferenceTriggeru"), (float)RefTrackPhi.size()); + PhiTT = RefTrackPhi[ii]; + EtaTT = RefTrackEta[ii]; + + } + + + else if(analyzeSignal==1&&SigTrackPhi.size()>0){ + + int ii = rand->Integer(SigTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 1.5); + spectra.fill(HIST("hPocetSignalTriggeru"), (float)SigTrackPhi.size()); + PhiTT = SigTrackPhi[ii]; + EtaTT = SigTrackEta[ii]; + + } + + spectra.fill(HIST("hPocetTracku"), i); + + + if(PhiTT < -100){ + return; + } + + + PerpConePhi = TVector2::Phi_mpi_pi(PhiTT- 0.5*TMath::Pi()); + + + + float ConePt = 0.; + for (const auto& track : tracks) + { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); + + float DPhiPerp = TVector2::Phi_mpi_pi(trackPhi - PerpConePhi); + float DEtaPerp = trackEta - EtaTT; + + if((DPhiPerp)*(DPhiPerp) + (DEtaPerp)*(DEtaPerp) < jetR2){ + ConePt = ConePt + trackPt; //FK KVULI E SCHEM BY SE MELY SCITAT 4vektory + } + + } + + float CorrConePt = ConePt - TMath::Pi()*jetR2*rho; + if (analyzeSignal==0){ + spectra.fill(HIST("hRefCorrConePt"), CorrConePt); + } + else{ + spectra.fill(HIST("hSigCorrConePt"), CorrConePt); + } + + int jj = 0; + float Jet1Phi = 0.; + float Jet1Eta = 0.; + float Jet2Phi = 0.; + float Jet2Eta = 0.; + + for (const auto& jet : jets){ + + jj ++; + + auto jetPt = jet.pt(); + + auto jetPhi = jet.phi(); + auto jetEta = jet.eta(); + float jetArea = jet.area(); + float jetPtCorr = jetPt - rho * jetArea; + + if(jj == 1){ + Jet1Phi = jetPhi; + Jet1Eta = jetEta; + } + + if(jj == 2){ + Jet2Phi = jetPhi; + Jet2Eta = jetEta; + } + + + + //FK TATO SPEKTRA SE PLNI JEN KDYZ JE TRIGGER. LEPE BY BYLO PLNIT SPEKTRA INKLUSIVNE + + spectra.fill(HIST("hJetPtCorr"), jetPtCorr); + spectra.fill(HIST("hJetPt"), jetPt); + spectra.fill(HIST("hJetPhi"), jetPhi); + spectra.fill(HIST("hJetEta"), jetEta); + + spectra.fill(HIST("hJetPtPhi"), jetPt, jetPhi); + spectra.fill(HIST("hJetPtEta"), jetPt, jetEta); + + spectra.fill(HIST("hJetPtPhiEta"), jetPt, jetPhi, jetEta); + + spectra.fill(HIST("hjetArea"), jetArea); + spectra.fill(HIST("JetAreavsPt"), jetPt, jetArea); + + + + + + float DPhi = -100; + DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetPhi- PhiTT)); + + if(DPhi > TMath::Pi() - DPhiCut){ + if(analyzeSignal == 0){ + spectra.fill(HIST("hRecoilJetRefPt"), jetPt); + spectra.fill(HIST("hRecoilJetRefCorrPt"), jetPtCorr); + } + else{ + spectra.fill(HIST("hRecoilJetSigPt"), jetPt); + spectra.fill(HIST("hRecoilJetSigCorrPt"), jetPtCorr); + } + } + + + } + + + + //printf("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"); + bool bCloseJet = true; + float randJetPhi = -999.; + float randJetEta = -999.; + while(bCloseJet){ //FK dat nejake pocitadlo, ktere umozni opustit loop + randJetPhi = rand->Uniform(-TMath::Pi(), TMath::Pi()); + randJetEta = rand->Uniform(-0.5, 0.5); + + float vphi1 = TVector2::Phi_mpi_pi(randJetPhi - Jet1Phi); + float vphi2 = TVector2::Phi_mpi_pi(randJetPhi - Jet2Phi); + float veta1 = randJetEta - Jet1Eta; + float veta2 = randJetEta - Jet2Eta; + float dist1 = sqrt(vphi1*vphi1 + veta1*veta1); + float dist2 = sqrt(vphi2*vphi2 + veta2*veta2); + + if(dist1 > 2*jetR && dist2 > 2*jetR) + bCloseJet = false; + } + + //printf("yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n"); + + + float RandConePt = 0.; + for (const auto& track : tracks) + { + if (skipTrack(track)) + continue; + + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); + float DPhiRand = TVector2::Phi_mpi_pi(trackPhi - randJetPhi); + float DEtaRand = trackEta - randJetEta; + + + if((DPhiRand)*(DPhiRand) + (DEtaRand)*(DEtaRand) < jetR2){ + RandConePt = RandConePt + trackPt; //FK scitat 4momenty + } + + } + + float CorrRandConePt = RandConePt - TMath::Pi()*jetR2*rho; + + if (analyzeSignal==0){ + spectra.fill(HIST("hRefRandCorrConePt"), CorrRandConePt); + } + else{ + spectra.fill(HIST("hSigRandCorrConePt"), CorrRandConePt); + } + + + } + + template + void fillMatchedHistograms(JTracksTable const& tracks, + JetsBase const& jetsBase, + JetsTag const& jetsTag, + float weight = 1.) + { + std::vector SigTrackPhi; + double PhiTT = 0.0; + + for (const auto& track : tracks) { + if (skipTrack(track)) + continue; + + if((SignalTriggerMin<=trackPt)&&(trackPt<=SignalTriggerMax)) + SigTrackPhi.push_back(track.phi()); + } + bool bIsThereTTSig = SigTrackPhi.size() > 0; + + if (bIsThereTTSig) + PhiTT = [rand->Integer(SigTrackPhi.size())]; + + for (const auto& jetBase : jetsBase) { + bool bIsBaseJetRecoil = false; + + if(bIsThereTTSig){ + float DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetBase.phi()- PhiTT)); + if(DPhi > TMath::Pi() - DPhiCut) + bIsBaseJetRecoil = true; + } + + dataForUnfolding(jetBase, jetsTag, bIsBaseJetRecoil, tracks, weight); + } + } + + + + + + + + + + void processCollisions(aod::JetCollisions::iterator const& collision) + { // no filtering on collisions + + spectra.fill(HIST("hEventSelectionCount"), 0.5); // all events without cuts + + // check whether event contains the required flag for event selection (sel8 in this case) + if (skipEvent(collision)) + return; + + spectra.fill(HIST("hEventSelectionCount"), 1.5); // number of events after applying event selection + spectra.fill(HIST("hVertexZ_NoCut"), collision.posZ()); + + // Imperative way to apply z-vertex cut (ineffective way, much faster is to apply the filter) + if (fabs(collision.posZ()) > vertexZCut) { + return; + } + + spectra.fill(HIST("hEventSelectionCount"), 2.5); // number of events after applying event selection + z-vertex cut + spectra.fill(HIST("hVertexZ_Cut"), collision.posZ()); + } + PROCESS_SWITCH(TrackJetSpectra, processCollisions, "process collisions", true); + + + void processFilteredCollisions(soa::Filtered::iterator const& collision) + { + // check whether event contains the required flag for event selection (sel8 in this case) + if (skipEvent(collision)) + return; + + spectra.fill(HIST("hVertexZ_EventFiltering"), collision.posZ()); // compare with "hVertexZ_Cut" histogram + } + PROCESS_SWITCH(TrackJetSpectra, processFilteredCollisions, "process filtered collisions", false); + + + void processTracks(soa::Filtered::iterator const& collision, + soa::Filtered const& tracks) + { + // check whether event contains the required flag for event selection (sel8 in this case) + if (skipEvent(collision)) + return; + + + int i = 0; + int PocetSigTrigeru = 0; + int PocetRefTrigeru = 0; + for (const auto& track : tracks) + { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + i++; + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); + + spectra.fill(HIST("hTrackPt"), trackPt); + spectra.fill(HIST("hTrackPhi"), trackPhi); + spectra.fill(HIST("hTrackEta"), trackEta); + + spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); + spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); + + spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); + + if((SignalTriggerMin<=trackPt)&&(trackPt<=SignalTriggerMax)) + PocetSigTrigeru++; + + + if((ReferenceTriggerMin<=trackPt)&&(trackPt<=ReferenceTriggerMax)) + PocetRefTrigeru++; + + + + + } + + spectra.fill(HIST("hPocetReferenceTriggeru"), PocetRefTrigeru); + spectra.fill(HIST("hPocetSignalTriggeru"), PocetSigTrigeru); + spectra.fill(HIST("hPocetTracku"), i); + } + + + + + + PROCESS_SWITCH(TrackJetSpectra, processTracks, "process tracks", false); + + + + + + + void processJets(FilteredColl const& collision, + soa::Filtered const& jets, + soa::Filtered const& tracks) + { + // check whether event contains the required flag for event selection (sel8 in this case) + + fillHistograms(collision, jets, tracks); + + } + + + PROCESS_SWITCH(TrackJetSpectra, processJets, "process inclusive jets", false); + + + void processJetsMCDet(FilteredColl const& collision, + FilteredJetsDetLevel const& jets, + soa::Filtered const& tracks) + { + // check whether event contains the required flag for event selection (sel8 in this case) + + fillHistograms(collision, jets, tracks); + + } + + + void processMCPartLevel(FilteredCollPartLevel const& collision, + FilteredParticles const& particles, + FilteredJetsPartLevel const& jets) + { + spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5); + + std::vector vPhiOfTT; + + float rnd = rand->Rndm(); + bool analyzeSignal =0; + float rho = collision.rho(); + + if (rnd < SigToRefFraction){ + analyzeSignal=1; + } + + + 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()) + continue; + + float particlePt = particle.pt(); + float particlePhi = particle.phi(); + + + + + + + if (analyzeSignal && (particlePt > SignalTriggerMin && particlePt < SignalTriggerMax)) { + vPhiOfTT.push_back(particlePhi); + + } + + if (!analyzeSignal && (particlePt > ReferenceTriggerMin && particlePt < ReferenceTriggerMax)) { + vPhiOfTT.push_back(particlePhi); + + } + } + int ii = -1; + if (vPhiOfTT.size() > 0){ + ii = rand->Integer(vPhiOfTT.size()); + if(analyzeSignal == 0){ + spectra.fill(HIST("hTTCountPartLevel"), 0.5); + } + else{ + spectra.fill(HIST("hTTCountPartLevel"), 1.5); + } + } + + + + for (const auto& jet : jets) { + float jetPt = jet.pt(); + float jetPhi = jet.phi(); + float jetArea = jet.area(); + float jetPtCorr = jetPt - rho * jetArea; + + spectra.fill(HIST("hJetPtEtaPhiRhoArea_Part"), jetPt, jet.eta(), jet.phi(), rho, jetArea); + + if (ii > -1) { + + + float PhiTT = vPhiOfTT[ii]; + + float DeltaPhi = TMath::Abs(TVector2::Phi_mpi_pi(PhiTT- jetPhi)); + if (DeltaPhi > TMath::Pi() - DPhiCut){ + if(analyzeSignal == 0){ + spectra.fill(HIST("hRecoilJetRefPtMCP"), jetPt); + spectra.fill(HIST("hRecoilJetRefCorrPtMCP"), jetPtCorr); + } + else{ + spectra.fill(HIST("hRecoilJetSigPtMCP"), jetPt); + spectra.fill(HIST("hRecoilJetSigCorrPtMCP"), jetPtCorr); + } + + + } + + + } + + + + } + } + + + + PROCESS_SWITCH(TrackJetSpectra, processJetsMCDet, "process inclusive jets", false); + + + void processJetsMatched(FilteredCollDetLevelGetWeight const& collision, + aod::JetMcCollisions const&, + FilteredTracks const& tracks, + FilteredMatchedJetsDetLevel const& mcdjets, + FilteredMatchedJetsPartLevel const& mcpjets) + { + if (skipEvent(collision)) + return; + + auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); + + fillMatchedHistograms(tracks, mcpjetsPerMCCollision, mcdjets); + } + PROCESS_SWITCH(TrackJetSpectra, processJetsMatched, "process matching of MC jets (no weight)", false); + + + //------------------------------------------------------------------------------ + // Auxiliary functions + template + bool skipEvent(const Collision& coll) + { + /// \brief: trigger cut is needed for pp data + return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits); + } + + template + bool skipTrack(const Track& track) + { + return !jetderiveddatautilities::selectTrack(track, trackSelection); + } + + + + template + bool isJetWithHighPtConstituent(Jet const& jet, Tracks const&) + { + bool bIsJetWithHighPtConstituent = false; + for (const auto& jetConstituent : jet.template tracks_as()) { + if (jetConstituent.pt() > maxJetConstituentPt) { + bIsJetWithHighPtConstituent = true; + break; + } + } + return bIsJetWithHighPtConstituent; + } + + + template + void dataForUnfolding(PartJet const& partJet, DetJet const& detJets, bool bIsBaseJetRecoil, TracksTable const& tracks, float weight = 1.) + { + + float partJetPt = partJet.pt(); + bool bIsThereMatchedJet = partJet.has_matchedJetGeo(); + + + //FK mame histogram particle level pT + + if (bIsThereMatchedJet) { + const auto& jetsMatched = partJet.template matchedJetGeo_as>(); + + for (const auto& jetMatched : jetsMatched) { + // skip matches where detector level jets have a constituent with pT above specified cut + bool skipMatchedDetJet = isJetWithHighPtConstituent(jetMatched, tracks); + + if (skipMatchedDetJet) { + // Miss jets + spectra.fill(HIST("hMissedJets_pT"), partJetPt, weight); + if (bIsBaseJetRecoil) + spectra.fill(HIST("hMissedJets_pT_RecoilJets"), partJetPt, weight); + } + else { + float detJetPt = jetMatched.pt(); + + spectra.fill(HIST("hJetPt_resolution"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hJetPhi_resolution"), partJet.phi() - jetMatched.phi(), partJetPt, weight); + + + if (bIsBaseJetRecoil) { + spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel_RecoilJets"), detJetPt, partJetPt, weight); + spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), partJet.phi() - jetMatched.phi(), partJetPt, weight); + } + } + + + } + } + } + + // template + // bool isJetWithHighPtConstituent(Jet const& jet, Tracks const&) + // { + // bool bIsJetWithHighPtConstituent = false; + // for (const auto& jetConstituent : jet.template tracks_as()) { + // if (jetConstituent.pt() > maxJetConstituentPt) { + // bIsJetWithHighPtConstituent = true; + // break; + // } + // } + // return bIsJetWithHighPtConstituent; + // } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From 9c562b60fd278c7fb935e01c4eeaf7b544a6a195 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 26 May 2026 08:42:43 +0000 Subject: [PATCH 2/5] Please consider the following formatting changes --- PWGJE/Tasks/trackJetSpectra.cxx | 849 ++++++++++++++------------------ 1 file changed, 371 insertions(+), 478 deletions(-) diff --git a/PWGJE/Tasks/trackJetSpectra.cxx b/PWGJE/Tasks/trackJetSpectra.cxx index 7e0555c091d..bc41006b1f1 100644 --- a/PWGJE/Tasks/trackJetSpectra.cxx +++ b/PWGJE/Tasks/trackJetSpectra.cxx @@ -35,8 +35,8 @@ #include "TRandom3.h" #include -#include #include +#include #include #include @@ -46,7 +46,6 @@ #include #include - using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; @@ -85,22 +84,22 @@ struct TrackJetSpectra { Configurable ReferenceTriggerMin{"RTriggerMin", 5., "Minimal Reference Trigger Track pT"}; Configurable ReferenceTriggerMax{"RTriggerMax", 7., "Maximal Reference Trigger Track pT"}; Configurable SigToRefFraction{"Fraction", 0.1, ""}; - Configurable DPhiCut{"DPhiCut", 0.6, ""}; + Configurable DPhiCut{"DPhiCut", 0.6, ""}; // List of configurable parameters for histograms Configurable histJetPt{"histJetPt", 150, "Maximum value of jet pT shown in histograms"}; - + Configurable meanFT0A{"meanFT0A", -1., "Mean value of FT0A signal"}; Configurable meanFT0C{"meanFT0C", -1., "Mean value of FT0C signal"}; //------------------------------------------------------------ - + TRandom3* rand = new TRandom3(0); // Declare filter on collision Z vertex Filter collisionFilter = nabs(aod::jcollision::posZ) < vertexZCut; Filter collisionFilterMC = nabs(aod::jmccollision::posZ) < vertexZCut; // Declare filters on accepted tracks and MC particles (settings for jet reco are provided in the jet finder wagon) - Filter trackFilter = aod::jtrack::pt > trkPtMin && aod::jtrack::pt < trkPtMax && nabs(aod::jtrack::eta) < trkEtaCut; + Filter trackFilter = aod::jtrack::pt > trkPtMin&& aod::jtrack::pt < trkPtMax&& nabs(aod::jtrack::eta) < trkEtaCut; Filter partFilter = nabs(aod::jmcparticle::eta) < trkEtaCut; // Declare filter on jets @@ -110,23 +109,22 @@ struct TrackJetSpectra { std::vector eventSelectionBits; int trackSelection = -1; - + Service pdg; Preslice partJetsPerCollision = aod::jet::mcCollisionId; void init(InitContext const&) { // Initialize histogram axes - AxisSpec pT{histJetPt+20, -20.0, histJetPt * 1., "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec pT{histJetPt + 20, -20.0, histJetPt * 1., "#it{p}_{T} (GeV/#it{c})"}; AxisSpec phiAngle{40, 0.0, constants::math::TwoPI, "#it{#varphi} (rad)"}; AxisSpec etaTracks{100, -1.0, 1.0, "#it{#eta}_{trk}"}; AxisSpec etaJets{100, -0.6, 0.6, "#it{#eta}_{jet}"}; - - + AxisSpec jetArea{50, 0.0, 3., "Area_{jet}"}; AxisSpec rho{50, 0.0, 50., "#it{#rho}"}; AxisSpec rhoArea{60, 0.0, 60., "#it{#rho} #times Area_{jet}"}; - + // Convert configurable strings to std::string std::string evSelToString = static_cast(evSel); std::string trkSelToString = static_cast(trkSel); @@ -144,92 +142,89 @@ struct TrackJetSpectra { or {nbins, min_value, max_value, "axis_title"} */ - - if(doprocessFilteredCollisions || doprocessCollisions) //FK AKTUALIZOVAT PODLE PROCESS FUNKCI + + if (doprocessFilteredCollisions || doprocessCollisions) // FK AKTUALIZOVAT PODLE PROCESS FUNKCI { - // Event selection - spectra.add("hEventSelectionCount", "Count # of events in the analysis", kTH1F, {{3, 0.0, 3.}}); - spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(1, "Total # of events w/o cuts"); - spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(2, Form("# of events after sel. %s", evSelToString.data())); - spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(3, "# of events after z cut"); //? - - // Z coordinate of collision vertex - spectra.add("hVertexZ_NoCut", "z vertex of collisions w/o cut", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); - spectra.add("hVertexZ_Cut", "z vertex of collisions w. cut", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); - spectra.add("hVertexZ_EventFiltering", "z vertex of collisions w. event filtering", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); + // Event selection + spectra.add("hEventSelectionCount", "Count # of events in the analysis", kTH1F, {{3, 0.0, 3.}}); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(1, "Total # of events w/o cuts"); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(2, Form("# of events after sel. %s", evSelToString.data())); + spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(3, "# of events after z cut"); //? + + // Z coordinate of collision vertex + spectra.add("hVertexZ_NoCut", "z vertex of collisions w/o cut", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); + spectra.add("hVertexZ_Cut", "z vertex of collisions w. cut", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); + spectra.add("hVertexZ_EventFiltering", "z vertex of collisions w. event filtering", kTH1F, {{100, -20., 20., "#it{z}_{vertex}"}}); } // Disitribution of tracks - if(doprocessTracks||doprocessJets) //FK AKTUALIZOVAT PODLE PROCESS FUNKCI I S OHLEDEM NA PARTICLE LEVEL + if (doprocessTracks || doprocessJets) // FK AKTUALIZOVAT PODLE PROCESS FUNKCI I S OHLEDEM NA PARTICLE LEVEL { - spectra.add("hPocetTracku", "Pocet", kTH1F, {{1000, 0., 1000., "Pocet Eventu"}}); - spectra.add("hPocetSignalTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hPocetReferenceTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); - spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); - spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); - - spectra.add("hTrackPtPhi", "#it{p}_{T} vs. #varphi distribution of tracks", kTH2F, {pT, phiAngle}); - spectra.add("hTrackPtEta", "#it{p}_{T} vs. #eta distribution of tracks", kTH2F, {pT, etaTracks}); - - spectra.add("hTrackPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of tracks", kTH3F, {pT, phiAngle, etaTracks}); - - // Distribution of jets - spectra.add("hJetPt", "#it{p}_{T} distribution of jets", kTH1F, {pT}); - spectra.add("hJetPhi", "#varphi distribution of jets", kTH1F, {phiAngle}); - spectra.add("hJetEta", "#eta distribution of jets", kTH1F, {etaJets}); - - spectra.add("hJetPtPhi", "#it{p}_{T} vs. #varphi distribution of jets", kTH2F, {pT, phiAngle}); - spectra.add("hJetPtEta", "#it{p}_{T} vs. #eta distribution of jets", kTH2F, {pT, etaJets}); - - spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); - - 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("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); - - spectra.add("hRho", "distribution of rho", kTH1F, {rho}); - spectra.add("hjetArea", "distribution of jet area", kTH1F, {jetArea}); - - spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); - spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); - - spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); - spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); - - spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH1F, {pT}); - spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH1F, {pT}); - - spectra.add("hEventSelectionCountPartLevel", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); - - spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); - - spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - - spectra.add("hTTCountPartLevel", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT MCP"}}); - spectra.add("hTTCountData", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT Data"}}); - - spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - - spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); - spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); - - spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); - spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); - spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); - - + spectra.add("hPocetTracku", "Pocet", kTH1F, {{1000, 0., 1000., "Pocet Eventu"}}); + spectra.add("hPocetSignalTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); + spectra.add("hPocetReferenceTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); + spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); + spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); + + spectra.add("hTrackPtPhi", "#it{p}_{T} vs. #varphi distribution of tracks", kTH2F, {pT, phiAngle}); + spectra.add("hTrackPtEta", "#it{p}_{T} vs. #eta distribution of tracks", kTH2F, {pT, etaTracks}); + + spectra.add("hTrackPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of tracks", kTH3F, {pT, phiAngle, etaTracks}); + + // Distribution of jets + spectra.add("hJetPt", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + spectra.add("hJetPhi", "#varphi distribution of jets", kTH1F, {phiAngle}); + spectra.add("hJetEta", "#eta distribution of jets", kTH1F, {etaJets}); + + spectra.add("hJetPtPhi", "#it{p}_{T} vs. #varphi distribution of jets", kTH2F, {pT, phiAngle}); + spectra.add("hJetPtEta", "#it{p}_{T} vs. #eta distribution of jets", kTH2F, {pT, etaJets}); + + spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); + + 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("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + + spectra.add("hRho", "distribution of rho", kTH1F, {rho}); + spectra.add("hjetArea", "distribution of jet area", kTH1F, {jetArea}); + + spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); + spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); + spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); + spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); + + spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH1F, {pT}); + spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH1F, {pT}); + + spectra.add("hEventSelectionCountPartLevel", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); + spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + + spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); + + spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); + + spectra.add("hTTCountPartLevel", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT MCP"}}); + spectra.add("hTTCountData", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT Data"}}); + + spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + + spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); + + spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); + spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); } } @@ -240,271 +235,234 @@ struct TrackJetSpectra { reduced information (aod::JetCollisions and aod::JetTracks). These tables are filled here: https://github.com/AliceO2Group/O2Physics/blob/4e284820d3b2f94327f0b71088c127decd74e8f9/PWGJE/TableProducer/derivedDataProducer.cxx Content of the tables can be found here: https://github.com/AliceO2Group/O2Physics/blob/cbc6e1f2eda0de5c8b00f64818e76eaa7e914232/PWGJE/DataModel/JetReducedData.h#L67 - - - + + + */ - - - - template + template void fillHistograms(Collision const& collision, Jets const& jets, Tracks const& tracks) - + { - if (skipEvent(collision)){ + if (skipEvent(collision)) { return; - } - - std::vector SigTrackPhi; - std::vector SigTrackEta; - std::vector RefTrackPhi; - std::vector RefTrackEta; - + } + + std::vector SigTrackPhi; + std::vector SigTrackEta; + std::vector RefTrackPhi; + std::vector RefTrackEta; + float multFT0A = collision.multFT0A(); float multFT0C = collision.multFT0C(); - //float multZNA = collision.multZNA(); - //float multZNC = collision.multZNC(); - + // float multZNA = collision.multZNA(); + // float multZNC = collision.multZNC(); + spectra.fill(HIST("hMultFT0A"), multFT0A); spectra.fill(HIST("hMultFT0C"), multFT0C); - - float jetR2 = jetR*jetR; + float jetR2 = jetR * jetR; float rho = collision.rho(); - + spectra.fill(HIST("hRho"), rho); - - int i = 0; - for (const auto& track : tracks) - { - // check whether track passes the selection flags - if (skipTrack(track)) - continue; - i++; - auto trackPt = track.pt(); - auto trackPhi = track.phi(); - auto trackEta = track.eta(); - - spectra.fill(HIST("hTrackPt"), trackPt); - spectra.fill(HIST("hTrackPhi"), trackPhi); - spectra.fill(HIST("hTrackEta"), trackEta); - - spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); - spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); - - spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); - - - - if((SignalTriggerMin<=trackPt)&&(trackPt<=SignalTriggerMax)){ - SigTrackPhi.push_back(trackPhi); - SigTrackEta.push_back(trackEta); - } - - if((ReferenceTriggerMin<=trackPt)&&(trackPt<=ReferenceTriggerMax)){ - RefTrackPhi.push_back(trackPhi); - RefTrackEta.push_back(trackEta); - } + int i = 0; + for (const auto& track : tracks) { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + i++; + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); + + spectra.fill(HIST("hTrackPt"), trackPt); + spectra.fill(HIST("hTrackPhi"), trackPhi); + spectra.fill(HIST("hTrackEta"), trackEta); + + spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); + spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); + + spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); + if ((SignalTriggerMin <= trackPt) && (trackPt <= SignalTriggerMax)) { + SigTrackPhi.push_back(trackPhi); + SigTrackEta.push_back(trackEta); + } + + if ((ReferenceTriggerMin <= trackPt) && (trackPt <= ReferenceTriggerMax)) { + RefTrackPhi.push_back(trackPhi); + RefTrackEta.push_back(trackEta); + } } spectra.fill(HIST("hRhovsNTracks"), i, rho); - + float PerpConePhi = -99; - float PhiTT = -999; //FK PSAT DO KODU KOMENTARE + float PhiTT = -999; // FK PSAT DO KODU KOMENTARE float EtaTT = -999; float rnd = rand->Rndm(); - bool analyzeSignal =0; - - if (rnd < SigToRefFraction){ - analyzeSignal=1; - + bool analyzeSignal = 0; + + if (rnd < SigToRefFraction) { + analyzeSignal = 1; } - if (analyzeSignal==0&&RefTrackPhi.size()>0){ - - int ii = rand->Integer(RefTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 0.5); - spectra.fill(HIST("hPocetReferenceTriggeru"), (float)RefTrackPhi.size()); - PhiTT = RefTrackPhi[ii]; - EtaTT = RefTrackEta[ii]; - + if (analyzeSignal == 0 && RefTrackPhi.size() > 0) { + + int ii = rand->Integer(RefTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 0.5); + spectra.fill(HIST("hPocetReferenceTriggeru"), (float)RefTrackPhi.size()); + PhiTT = RefTrackPhi[ii]; + EtaTT = RefTrackEta[ii]; + } - - - else if(analyzeSignal==1&&SigTrackPhi.size()>0){ - - int ii = rand->Integer(SigTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 1.5); - spectra.fill(HIST("hPocetSignalTriggeru"), (float)SigTrackPhi.size()); - PhiTT = SigTrackPhi[ii]; - EtaTT = SigTrackEta[ii]; - + + else if (analyzeSignal == 1 && SigTrackPhi.size() > 0) { + + int ii = rand->Integer(SigTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 1.5); + spectra.fill(HIST("hPocetSignalTriggeru"), (float)SigTrackPhi.size()); + PhiTT = SigTrackPhi[ii]; + EtaTT = SigTrackEta[ii]; } - - spectra.fill(HIST("hPocetTracku"), i); - - if(PhiTT < -100){ - return; + spectra.fill(HIST("hPocetTracku"), i); + + if (PhiTT < -100) { + return; } - - - PerpConePhi = TVector2::Phi_mpi_pi(PhiTT- 0.5*TMath::Pi()); - - - + + PerpConePhi = TVector2::Phi_mpi_pi(PhiTT - 0.5 * TMath::Pi()); + float ConePt = 0.; - for (const auto& track : tracks) - { - // check whether track passes the selection flags - if (skipTrack(track)) - continue; - - auto trackPt = track.pt(); - auto trackPhi = track.phi(); - auto trackEta = track.eta(); - - float DPhiPerp = TVector2::Phi_mpi_pi(trackPhi - PerpConePhi); - float DEtaPerp = trackEta - EtaTT; - - if((DPhiPerp)*(DPhiPerp) + (DEtaPerp)*(DEtaPerp) < jetR2){ - ConePt = ConePt + trackPt; //FK KVULI E SCHEM BY SE MELY SCITAT 4vektory - } - - } - - float CorrConePt = ConePt - TMath::Pi()*jetR2*rho; - if (analyzeSignal==0){ - spectra.fill(HIST("hRefCorrConePt"), CorrConePt); + for (const auto& track : tracks) { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); + + float DPhiPerp = TVector2::Phi_mpi_pi(trackPhi - PerpConePhi); + float DEtaPerp = trackEta - EtaTT; + + if ((DPhiPerp) * (DPhiPerp) + (DEtaPerp) * (DEtaPerp) < jetR2) { + ConePt = ConePt + trackPt; // FK KVULI E SCHEM BY SE MELY SCITAT 4vektory + } } - else{ - spectra.fill(HIST("hSigCorrConePt"), CorrConePt); + + float CorrConePt = ConePt - TMath::Pi() * jetR2 * rho; + if (analyzeSignal == 0) { + spectra.fill(HIST("hRefCorrConePt"), CorrConePt); + } else { + spectra.fill(HIST("hSigCorrConePt"), CorrConePt); } - + int jj = 0; float Jet1Phi = 0.; float Jet1Eta = 0.; float Jet2Phi = 0.; float Jet2Eta = 0.; - - for (const auto& jet : jets){ - - jj ++; - - auto jetPt = jet.pt(); - - auto jetPhi = jet.phi(); - auto jetEta = jet.eta(); - float jetArea = jet.area(); - float jetPtCorr = jetPt - rho * jetArea; - - if(jj == 1){ - Jet1Phi = jetPhi; - Jet1Eta = jetEta; - } - - if(jj == 2){ - Jet2Phi = jetPhi; - Jet2Eta = jetEta; - } - - - - //FK TATO SPEKTRA SE PLNI JEN KDYZ JE TRIGGER. LEPE BY BYLO PLNIT SPEKTRA INKLUSIVNE - - spectra.fill(HIST("hJetPtCorr"), jetPtCorr); - spectra.fill(HIST("hJetPt"), jetPt); - spectra.fill(HIST("hJetPhi"), jetPhi); - spectra.fill(HIST("hJetEta"), jetEta); - - spectra.fill(HIST("hJetPtPhi"), jetPt, jetPhi); - spectra.fill(HIST("hJetPtEta"), jetPt, jetEta); - - spectra.fill(HIST("hJetPtPhiEta"), jetPt, jetPhi, jetEta); - - spectra.fill(HIST("hjetArea"), jetArea); - spectra.fill(HIST("JetAreavsPt"), jetPt, jetArea); - - - - - - float DPhi = -100; - DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetPhi- PhiTT)); - - if(DPhi > TMath::Pi() - DPhiCut){ - if(analyzeSignal == 0){ - spectra.fill(HIST("hRecoilJetRefPt"), jetPt); - spectra.fill(HIST("hRecoilJetRefCorrPt"), jetPtCorr); - } - else{ - spectra.fill(HIST("hRecoilJetSigPt"), jetPt); - spectra.fill(HIST("hRecoilJetSigCorrPt"), jetPtCorr); - } + + for (const auto& jet : jets) { + + jj++; + + auto jetPt = jet.pt(); + + auto jetPhi = jet.phi(); + auto jetEta = jet.eta(); + float jetArea = jet.area(); + float jetPtCorr = jetPt - rho * jetArea; + + if (jj == 1) { + Jet1Phi = jetPhi; + Jet1Eta = jetEta; + } + + if (jj == 2) { + Jet2Phi = jetPhi; + Jet2Eta = jetEta; + } + + // FK TATO SPEKTRA SE PLNI JEN KDYZ JE TRIGGER. LEPE BY BYLO PLNIT SPEKTRA INKLUSIVNE + + spectra.fill(HIST("hJetPtCorr"), jetPtCorr); + spectra.fill(HIST("hJetPt"), jetPt); + spectra.fill(HIST("hJetPhi"), jetPhi); + spectra.fill(HIST("hJetEta"), jetEta); + + spectra.fill(HIST("hJetPtPhi"), jetPt, jetPhi); + spectra.fill(HIST("hJetPtEta"), jetPt, jetEta); + + spectra.fill(HIST("hJetPtPhiEta"), jetPt, jetPhi, jetEta); + + spectra.fill(HIST("hjetArea"), jetArea); + spectra.fill(HIST("JetAreavsPt"), jetPt, jetArea); + + float DPhi = -100; + DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetPhi - PhiTT)); + + if (DPhi > TMath::Pi() - DPhiCut) { + if (analyzeSignal == 0) { + spectra.fill(HIST("hRecoilJetRefPt"), jetPt); + spectra.fill(HIST("hRecoilJetRefCorrPt"), jetPtCorr); + } else { + spectra.fill(HIST("hRecoilJetSigPt"), jetPt); + spectra.fill(HIST("hRecoilJetSigCorrPt"), jetPtCorr); } - - + } } - - - //printf("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"); - bool bCloseJet = true; + // printf("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"); + bool bCloseJet = true; float randJetPhi = -999.; float randJetEta = -999.; - while(bCloseJet){ //FK dat nejake pocitadlo, ktere umozni opustit loop - randJetPhi = rand->Uniform(-TMath::Pi(), TMath::Pi()); - randJetEta = rand->Uniform(-0.5, 0.5); - - float vphi1 = TVector2::Phi_mpi_pi(randJetPhi - Jet1Phi); - float vphi2 = TVector2::Phi_mpi_pi(randJetPhi - Jet2Phi); - float veta1 = randJetEta - Jet1Eta; - float veta2 = randJetEta - Jet2Eta; - float dist1 = sqrt(vphi1*vphi1 + veta1*veta1); - float dist2 = sqrt(vphi2*vphi2 + veta2*veta2); - - if(dist1 > 2*jetR && dist2 > 2*jetR) - bCloseJet = false; + while (bCloseJet) { // FK dat nejake pocitadlo, ktere umozni opustit loop + randJetPhi = rand->Uniform(-TMath::Pi(), TMath::Pi()); + randJetEta = rand->Uniform(-0.5, 0.5); + + float vphi1 = TVector2::Phi_mpi_pi(randJetPhi - Jet1Phi); + float vphi2 = TVector2::Phi_mpi_pi(randJetPhi - Jet2Phi); + float veta1 = randJetEta - Jet1Eta; + float veta2 = randJetEta - Jet2Eta; + float dist1 = sqrt(vphi1 * vphi1 + veta1 * veta1); + float dist2 = sqrt(vphi2 * vphi2 + veta2 * veta2); + + if (dist1 > 2 * jetR && dist2 > 2 * jetR) + bCloseJet = false; } - - //printf("yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n"); - + // printf("yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n"); + float RandConePt = 0.; - for (const auto& track : tracks) - { - if (skipTrack(track)) - continue; - - auto trackPt = track.pt(); - auto trackPhi = track.phi(); - auto trackEta = track.eta(); - float DPhiRand = TVector2::Phi_mpi_pi(trackPhi - randJetPhi); - float DEtaRand = trackEta - randJetEta; - - - if((DPhiRand)*(DPhiRand) + (DEtaRand)*(DEtaRand) < jetR2){ - RandConePt = RandConePt + trackPt; //FK scitat 4momenty - } - - } - - float CorrRandConePt = RandConePt - TMath::Pi()*jetR2*rho; - - if (analyzeSignal==0){ - spectra.fill(HIST("hRefRandCorrConePt"), CorrRandConePt); - } - else{ - spectra.fill(HIST("hSigRandCorrConePt"), CorrRandConePt); - } - - - } + for (const auto& track : tracks) { + if (skipTrack(track)) + continue; + + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); + float DPhiRand = TVector2::Phi_mpi_pi(trackPhi - randJetPhi); + float DEtaRand = trackEta - randJetEta; + + if ((DPhiRand) * (DPhiRand) + (DEtaRand) * (DEtaRand) < jetR2) { + RandConePt = RandConePt + trackPt; // FK scitat 4momenty + } + } + + float CorrRandConePt = RandConePt - TMath::Pi() * jetR2 * rho; + + if (analyzeSignal == 0) { + spectra.fill(HIST("hRefRandCorrConePt"), CorrRandConePt); + } else { + spectra.fill(HIST("hSigRandCorrConePt"), CorrRandConePt); + } + } template void fillMatchedHistograms(JTracksTable const& tracks, @@ -512,41 +470,33 @@ struct TrackJetSpectra { JetsTag const& jetsTag, float weight = 1.) { - std::vector SigTrackPhi; - double PhiTT = 0.0; + std::vector SigTrackPhi; + double PhiTT = 0.0; - for (const auto& track : tracks) { - if (skipTrack(track)) - continue; + for (const auto& track : tracks) { + if (skipTrack(track)) + continue; - if((SignalTriggerMin<=trackPt)&&(trackPt<=SignalTriggerMax)) - SigTrackPhi.push_back(track.phi()); - } - bool bIsThereTTSig = SigTrackPhi.size() > 0; + if ((SignalTriggerMin <= trackPt) && (trackPt <= SignalTriggerMax)) + SigTrackPhi.push_back(track.phi()); + } + bool bIsThereTTSig = SigTrackPhi.size() > 0; if (bIsThereTTSig) - PhiTT = [rand->Integer(SigTrackPhi.size())]; + PhiTT = [rand->Integer(SigTrackPhi.size())]; for (const auto& jetBase : jetsBase) { - bool bIsBaseJetRecoil = false; + bool bIsBaseJetRecoil = false; - if(bIsThereTTSig){ - float DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetBase.phi()- PhiTT)); - if(DPhi > TMath::Pi() - DPhiCut) + if (bIsThereTTSig) { + float DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetBase.phi() - PhiTT)); + if (DPhi > TMath::Pi() - DPhiCut) bIsBaseJetRecoil = true; - } - - dataForUnfolding(jetBase, jetsTag, bIsBaseJetRecoil, tracks, weight); + } + + dataForUnfolding(jetBase, jetsTag, bIsBaseJetRecoil, tracks, weight); } } - - - - - - - - void processCollisions(aod::JetCollisions::iterator const& collision) { // no filtering on collisions @@ -565,12 +515,11 @@ struct TrackJetSpectra { return; } - spectra.fill(HIST("hEventSelectionCount"), 2.5); // number of events after applying event selection + z-vertex cut + spectra.fill(HIST("hEventSelectionCount"), 2.5); // number of events after applying event selection + z-vertex cut spectra.fill(HIST("hVertexZ_Cut"), collision.posZ()); } PROCESS_SWITCH(TrackJetSpectra, processCollisions, "process collisions", true); - void processFilteredCollisions(soa::Filtered::iterator const& collision) { // check whether event contains the required flag for event selection (sel8 in this case) @@ -581,7 +530,6 @@ struct TrackJetSpectra { } PROCESS_SWITCH(TrackJetSpectra, processFilteredCollisions, "process filtered collisions", false); - void processTracks(soa::Filtered::iterator const& collision, soa::Filtered const& tracks) { @@ -589,142 +537,108 @@ struct TrackJetSpectra { if (skipEvent(collision)) return; - int i = 0; - int PocetSigTrigeru = 0; - int PocetRefTrigeru = 0; - for (const auto& track : tracks) - { - // check whether track passes the selection flags - if (skipTrack(track)) - continue; - i++; - auto trackPt = track.pt(); - auto trackPhi = track.phi(); - auto trackEta = track.eta(); - - spectra.fill(HIST("hTrackPt"), trackPt); - spectra.fill(HIST("hTrackPhi"), trackPhi); - spectra.fill(HIST("hTrackEta"), trackEta); - - spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); - spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); - - spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); - - if((SignalTriggerMin<=trackPt)&&(trackPt<=SignalTriggerMax)) - PocetSigTrigeru++; - + int PocetSigTrigeru = 0; + int PocetRefTrigeru = 0; + for (const auto& track : tracks) { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + i++; + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); - if((ReferenceTriggerMin<=trackPt)&&(trackPt<=ReferenceTriggerMax)) - PocetRefTrigeru++; + spectra.fill(HIST("hTrackPt"), trackPt); + spectra.fill(HIST("hTrackPhi"), trackPhi); + spectra.fill(HIST("hTrackEta"), trackEta); + spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); + spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); + spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); + if ((SignalTriggerMin <= trackPt) && (trackPt <= SignalTriggerMax)) + PocetSigTrigeru++; + if ((ReferenceTriggerMin <= trackPt) && (trackPt <= ReferenceTriggerMax)) + PocetRefTrigeru++; } - - spectra.fill(HIST("hPocetReferenceTriggeru"), PocetRefTrigeru); - spectra.fill(HIST("hPocetSignalTriggeru"), PocetSigTrigeru); - spectra.fill(HIST("hPocetTracku"), i); + + spectra.fill(HIST("hPocetReferenceTriggeru"), PocetRefTrigeru); + spectra.fill(HIST("hPocetSignalTriggeru"), PocetSigTrigeru); + spectra.fill(HIST("hPocetTracku"), i); } - - - - PROCESS_SWITCH(TrackJetSpectra, processTracks, "process tracks", false); - - - - - void processJets(FilteredColl const& collision, soa::Filtered const& jets, soa::Filtered const& tracks) { // check whether event contains the required flag for event selection (sel8 in this case) - + fillHistograms(collision, jets, tracks); - - } - - - PROCESS_SWITCH(TrackJetSpectra, processJets, "process inclusive jets", false); - - - void processJetsMCDet(FilteredColl const& collision, - FilteredJetsDetLevel const& jets, - soa::Filtered const& tracks) + } + + PROCESS_SWITCH(TrackJetSpectra, processJets, "process inclusive jets", false); + + void processJetsMCDet(FilteredColl const& collision, + FilteredJetsDetLevel const& jets, + soa::Filtered const& tracks) { // check whether event contains the required flag for event selection (sel8 in this case) - + fillHistograms(collision, jets, tracks); - - } - - - void processMCPartLevel(FilteredCollPartLevel const& collision, + } + + void processMCPartLevel(FilteredCollPartLevel const& collision, FilteredParticles const& particles, FilteredJetsPartLevel const& jets) { spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5); - + std::vector vPhiOfTT; - + float rnd = rand->Rndm(); - bool analyzeSignal =0; + bool analyzeSignal = 0; float rho = collision.rho(); - - if (rnd < SigToRefFraction){ - analyzeSignal=1; + + if (rnd < SigToRefFraction) { + analyzeSignal = 1; } - - + 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()) continue; - + float particlePt = particle.pt(); float particlePhi = particle.phi(); - - - - - if (analyzeSignal && (particlePt > SignalTriggerMin && particlePt < SignalTriggerMax)) { vPhiOfTT.push_back(particlePhi); - } if (!analyzeSignal && (particlePt > ReferenceTriggerMin && particlePt < ReferenceTriggerMax)) { vPhiOfTT.push_back(particlePhi); - } } int ii = -1; - if (vPhiOfTT.size() > 0){ - ii = rand->Integer(vPhiOfTT.size()); - if(analyzeSignal == 0){ - spectra.fill(HIST("hTTCountPartLevel"), 0.5); - } - else{ - spectra.fill(HIST("hTTCountPartLevel"), 1.5); - } + if (vPhiOfTT.size() > 0) { + ii = rand->Integer(vPhiOfTT.size()); + if (analyzeSignal == 0) { + spectra.fill(HIST("hTTCountPartLevel"), 0.5); + } else { + spectra.fill(HIST("hTTCountPartLevel"), 1.5); + } } - - for (const auto& jet : jets) { float jetPt = jet.pt(); float jetPhi = jet.phi(); @@ -732,40 +646,28 @@ struct TrackJetSpectra { float jetPtCorr = jetPt - rho * jetArea; spectra.fill(HIST("hJetPtEtaPhiRhoArea_Part"), jetPt, jet.eta(), jet.phi(), rho, jetArea); - + if (ii > -1) { - - float PhiTT = vPhiOfTT[ii]; - - float DeltaPhi = TMath::Abs(TVector2::Phi_mpi_pi(PhiTT- jetPhi)); - if (DeltaPhi > TMath::Pi() - DPhiCut){ - if(analyzeSignal == 0){ - spectra.fill(HIST("hRecoilJetRefPtMCP"), jetPt); - spectra.fill(HIST("hRecoilJetRefCorrPtMCP"), jetPtCorr); - } - else{ - spectra.fill(HIST("hRecoilJetSigPtMCP"), jetPt); - spectra.fill(HIST("hRecoilJetSigCorrPtMCP"), jetPtCorr); - } - - - } - - + float PhiTT = vPhiOfTT[ii]; + + float DeltaPhi = TMath::Abs(TVector2::Phi_mpi_pi(PhiTT - jetPhi)); + if (DeltaPhi > TMath::Pi() - DPhiCut) { + if (analyzeSignal == 0) { + spectra.fill(HIST("hRecoilJetRefPtMCP"), jetPt); + spectra.fill(HIST("hRecoilJetRefCorrPtMCP"), jetPtCorr); + } else { + spectra.fill(HIST("hRecoilJetSigPtMCP"), jetPt); + spectra.fill(HIST("hRecoilJetSigCorrPtMCP"), jetPtCorr); } - - - + } } } - - - + } + PROCESS_SWITCH(TrackJetSpectra, processJetsMCDet, "process inclusive jets", false); - - - void processJetsMatched(FilteredCollDetLevelGetWeight const& collision, + + void processJetsMatched(FilteredCollDetLevelGetWeight const& collision, aod::JetMcCollisions const&, FilteredTracks const& tracks, FilteredMatchedJetsDetLevel const& mcdjets, @@ -780,7 +682,6 @@ struct TrackJetSpectra { } PROCESS_SWITCH(TrackJetSpectra, processJetsMatched, "process matching of MC jets (no weight)", false); - //------------------------------------------------------------------------------ // Auxiliary functions template @@ -795,9 +696,7 @@ struct TrackJetSpectra { { return !jetderiveddatautilities::selectTrack(track, trackSelection); } - - - + template bool isJetWithHighPtConstituent(Jet const& jet, Tracks const&) { @@ -810,46 +709,40 @@ struct TrackJetSpectra { } return bIsJetWithHighPtConstituent; } - - + template void dataForUnfolding(PartJet const& partJet, DetJet const& detJets, bool bIsBaseJetRecoil, TracksTable const& tracks, float weight = 1.) { float partJetPt = partJet.pt(); bool bIsThereMatchedJet = partJet.has_matchedJetGeo(); - - - //FK mame histogram particle level pT + + // FK mame histogram particle level pT if (bIsThereMatchedJet) { - const auto& jetsMatched = partJet.template matchedJetGeo_as>(); - - for (const auto& jetMatched : jetsMatched) { + const auto& jetsMatched = partJet.template matchedJetGeo_as>(); + + for (const auto& jetMatched : jetsMatched) { // skip matches where detector level jets have a constituent with pT above specified cut bool skipMatchedDetJet = isJetWithHighPtConstituent(jetMatched, tracks); - + if (skipMatchedDetJet) { // Miss jets spectra.fill(HIST("hMissedJets_pT"), partJetPt, weight); if (bIsBaseJetRecoil) spectra.fill(HIST("hMissedJets_pT_RecoilJets"), partJetPt, weight); - } - else { - float detJetPt = jetMatched.pt(); - - spectra.fill(HIST("hJetPt_resolution"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); - spectra.fill(HIST("hJetPhi_resolution"), partJet.phi() - jetMatched.phi(), partJetPt, weight); + } else { + float detJetPt = jetMatched.pt(); + spectra.fill(HIST("hJetPt_resolution"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hJetPhi_resolution"), partJet.phi() - jetMatched.phi(), partJetPt, weight); - if (bIsBaseJetRecoil) { - spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel_RecoilJets"), detJetPt, partJetPt, weight); - spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); - spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), partJet.phi() - jetMatched.phi(), partJetPt, weight); + if (bIsBaseJetRecoil) { + spectra.fill(HIST("hJetPt_DetLevel_vs_PartLevel_RecoilJets"), detJetPt, partJetPt, weight); + spectra.fill(HIST("hJetPt_resolution_RecoilJets"), (partJetPt - detJetPt) / partJetPt, partJetPt, weight); + spectra.fill(HIST("hJetPhi_resolution_RecoilJets"), partJet.phi() - jetMatched.phi(), partJetPt, weight); } } - - } } } From d56d0da1e6f9055e686dbf7f05200d91990c9ba9 Mon Sep 17 00:00:00 2001 From: fkrizek Date: Tue, 26 May 2026 15:23:59 +0200 Subject: [PATCH 3/5] Address comments --- PWGJE/Tasks/trackJetSpectra.cxx | 781 ++++++++++++++++++++------------ 1 file changed, 503 insertions(+), 278 deletions(-) diff --git a/PWGJE/Tasks/trackJetSpectra.cxx b/PWGJE/Tasks/trackJetSpectra.cxx index bc41006b1f1..dec02c25020 100644 --- a/PWGJE/Tasks/trackJetSpectra.cxx +++ b/PWGJE/Tasks/trackJetSpectra.cxx @@ -1,4 +1,4 @@ -// Copyright 2020-2022 CERN and copyright holders of ALICE O2. +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // @@ -9,9 +9,9 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -/// \author Kotliarov Artem /// \file trackJetSpectra.cxx -/// \brief track and jet analysis +/// \brief Analysis task for charged jet and track spectra studies +/// \author Janis Jan #include "PWGJE/Core/JetDerivedDataUtilities.h" #include "PWGJE/DataModel/Jet.h" @@ -34,6 +34,7 @@ #include #include "TRandom3.h" +#include #include #include #include @@ -59,10 +60,25 @@ using FilteredJetsPartLevel = soa::Filtered>::iterator; using FilteredCollPartLevel = soa::Filtered>::iterator; + +using CollPartLevelEfficiencyWeighted = soa::Join::iterator; + +using FilteredCollPartLevelMB = soa::Filtered>::iterator; + +using CollPartLevelMBEfficiency = aod::JetMcCollisions::iterator; + +using CollisionMCD = soa::SmallGroups; + using FilteredParticles = soa::Filtered; -using FilteredJetsPartLevel = soa::Filtered>; + +using FilteredTracksMatch = soa::Filtered>; + +using ParticlesFullTable = soa::Join; + +using TracksMCDetFullTable = soa::Join; using FilteredTracks = soa::Filtered; + using FilteredMatchedJetsDetLevel = soa::Filtered>; using FilteredMatchedJetsPartLevel = soa::Filtered>; @@ -71,7 +87,9 @@ struct TrackJetSpectra { // List of configurable parameters Configurable evSel{"evSel", "sel8", "Choose event selection"}; Configurable trkSel{"trkSel", "globalTracks", "Set track selection"}; + Configurable setSumw2{"setSumw2", false, "Enable Sum2w() calculation for histograms"}; Configurable vertexZCut{"vertexZCut", 10., "Accepted z-vertex range"}; + Configurable maxJetConstituentPt{"maxJetConstituentPt", 100., "Remove jets with constituent above this pT cut"}; Configurable trkPtMin{"trkPtMin", 0.15, "Minimum pT of acceptanced tracks"}; Configurable trkPtMax{"trkPtMax", 100., "Maximum pT of acceptanced tracks"}; @@ -79,18 +97,30 @@ struct TrackJetSpectra { Configurable trkEtaCut{"trkEtaCut", 0.9, "Eta acceptance of TPC"}; Configurable jetR{"jetR", 0.4, "Jet cone radius"}; - Configurable SignalTriggerMin{"STriggerMin", 15., "Minimal Signal Trigger Track pT"}; - Configurable SignalTriggerMax{"STriggerMax", 50., "Maximal Signal Trigger Track pT"}; - Configurable ReferenceTriggerMin{"RTriggerMin", 5., "Minimal Reference Trigger Track pT"}; - Configurable ReferenceTriggerMax{"RTriggerMax", 7., "Maximal Reference Trigger Track pT"}; - Configurable SigToRefFraction{"Fraction", 0.1, ""}; - Configurable DPhiCut{"DPhiCut", 0.6, ""}; + Configurable signalTriggerMin{"signalTriggerMin", 15.f, "Minimal signal trigger track pT"}; + + Configurable signalTriggerMax{"signalTriggerMax", 50.f, "Maximal signal trigger track pT"}; + + Configurable referenceTriggerMin{"referenceTriggerMin", 5.f, "Minimal reference trigger track pT"}; + + Configurable referenceTriggerMax{"referenceTriggerMax", 7.f, "Maximal reference trigger track pT"}; + + Configurable sigToRefFraction{"sigToRefFraction", 0.1f, "Signal-to-reference trigger fraction"}; + Configurable dPhiCut{"dPhiCut", 0.6, ""}; // List of configurable parameters for histograms Configurable histJetPt{"histJetPt", 150, "Maximum value of jet pT shown in histograms"}; Configurable meanFT0A{"meanFT0A", -1., "Mean value of FT0A signal"}; Configurable meanFT0C{"meanFT0C", -1., "Mean value of FT0C signal"}; + Configurable pionMass{"pionMass", o2::constants::physics::MassPiPlus, "Mass of a pion"}; + + Configurable isMCJJProd{"isMCJJProd", false, "Flag to select MC production: MB (false) or JJ(true)"}, + skipMBGapEvents{"skipMBGapEvents", false, + "Flag to choose to reject min. bias gap events; jet-level rejection " + "applied at the jet finder level, here rejection is applied for " + "collision and track process functions"}; + //------------------------------------------------------------ TRandom3* rand = new TRandom3(0); @@ -113,18 +143,26 @@ struct TrackJetSpectra { Service pdg; Preslice partJetsPerCollision = aod::jet::mcCollisionId; + Preslice tracksPerJCollision = o2::aod::jtrack::collisionId; + void init(InitContext const&) { // Initialize histogram axes AxisSpec pT{histJetPt + 20, -20.0, histJetPt * 1., "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec pTRes{100, -5.0, 5.0, "#it{p}_{T} Resolution"}; + AxisSpec pTTrack{100, 0.0, 100.0, "#it{p}_{T,Track} (GeV/#it{c})"}; AxisSpec phiAngle{40, 0.0, constants::math::TwoPI, "#it{#varphi} (rad)"}; + AxisSpec dphiAngle{400, -1.0, 1.0, "#it{#varphi} (rad)"}; AxisSpec etaTracks{100, -1.0, 1.0, "#it{#eta}_{trk}"}; + AxisSpec detaTracks{400, -0.9, 0.9, "#it{#eta}_{trk}"}; AxisSpec etaJets{100, -0.6, 0.6, "#it{#eta}_{jet}"}; AxisSpec jetArea{50, 0.0, 3., "Area_{jet}"}; AxisSpec rho{50, 0.0, 50., "#it{#rho}"}; AxisSpec rhoArea{60, 0.0, 60., "#it{#rho} #times Area_{jet}"}; + AxisSpec centrality{10, 0.0, 100., "centrality"}; + // Convert configurable strings to std::string std::string evSelToString = static_cast(evSel); std::string trkSelToString = static_cast(trkSel); @@ -132,19 +170,7 @@ struct TrackJetSpectra { eventSelectionBits = jetderiveddatautilities::initialiseEventSelectionBits(evSelToString); trackSelection = jetderiveddatautilities::initialiseTrackSelection(trkSelToString); - /* - How to add histograms: - - spectra.add("histogram_name", "Histogram title", histogram_type (kTH1F/kTH1D and so on), {axis1, axis2, ...}); - where axis is definened as: - - AxisSpec axis_name{nbins, min_value, max_value, "axis_title"}; - or - {nbins, min_value, max_value, "axis_title"} - */ - - if (doprocessFilteredCollisions || doprocessCollisions) // FK AKTUALIZOVAT PODLE PROCESS FUNKCI - { + if (doprocessFilteredCollisions) { // Event selection spectra.add("hEventSelectionCount", "Count # of events in the analysis", kTH1F, {{3, 0.0, 3.}}); spectra.get(HIST("hEventSelectionCount"))->GetXaxis()->SetBinLabel(1, "Total # of events w/o cuts"); @@ -158,16 +184,15 @@ struct TrackJetSpectra { } // Disitribution of tracks - if (doprocessTracks || doprocessJets) // FK AKTUALIZOVAT PODLE PROCESS FUNKCI I S OHLEDEM NA PARTICLE LEVEL - { + if (doprocessJetsMCDet || doprocessJetsMCDetWeighted || doprocessJets) { spectra.add("hPocetTracku", "Pocet", kTH1F, {{1000, 0., 1000., "Pocet Eventu"}}); spectra.add("hPocetSignalTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); spectra.add("hPocetReferenceTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); + spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); + spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); + spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); + spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH2F, {pT, centrality}); spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); @@ -186,8 +211,8 @@ struct TrackJetSpectra { spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); - 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("hMultFT0A", "Mult. signal from FTOA", kTH2F, {{2000, 0.0, 40000., "FT0A"}, centrality}); + spectra.add("hMultFT0C", "Mult. signal from FTOC", kTH2F, {{2000, 0.0, 40000., "FT0C"}, centrality}); spectra.add("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); @@ -196,25 +221,20 @@ struct TrackJetSpectra { spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); + spectra.add("hRhovsCentrality", "Rho vs number of tracks", kTH2F, {centrality, rho}); spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); - spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH1F, {pT}); - spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH1F, {pT}); + spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH2F, {pT, centrality}); + spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH2F, {pT, centrality}); - spectra.add("hEventSelectionCountPartLevel", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); - - spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); + spectra.add("hTTCountData", "Pocet", kTH2F, {{2, 0., 2., "Pocet TT Data"}, centrality}); + } - spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "Pocet Eventu"}}); - - spectra.add("hTTCountPartLevel", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT MCP"}}); - spectra.add("hTTCountData", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT Data"}}); + if (doprocessJetsMatched) { + spectra.add("hDetLevelInclusiveJetsPt", "All reconstructed inclusive jets", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hFakeInclusiveJetsPt", "Det. level inclusive jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); @@ -226,47 +246,66 @@ struct TrackJetSpectra { spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); } - } - //------------------------------------------------------------------------------ - /* - In jet group, we do not use general information about collisions and tracks. We simply do not - need all that information for jet finding and jet analysis. Therefore, we use ASoA tables with - reduced information (aod::JetCollisions and aod::JetTracks). These tables are filled here: https://github.com/AliceO2Group/O2Physics/blob/4e284820d3b2f94327f0b71088c127decd74e8f9/PWGJE/TableProducer/derivedDataProducer.cxx + if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { + spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - Content of the tables can be found here: https://github.com/AliceO2Group/O2Physics/blob/cbc6e1f2eda0de5c8b00f64818e76eaa7e914232/PWGJE/DataModel/JetReducedData.h#L67 + spectra.add("hEventSelectionCountPartLevel", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); + spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + + spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); + spectra.add("hJetPtMCP", "#it{p}_{T} distribution of jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hTTCountPartLevel", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT MCP"}}); + } + if (doprocessTrackEfficiency || doprocessTrackEfficiencyMB) { + spectra.add("hTrackingEfficiencyDenominatorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + spectra.add("hNonprimaryParticlesPt", "#it{p}_{T} distribution", kTH1F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}}); + spectra.add("hTrackingEfficiencyNumeratorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); - */ + spectra.add("hTrackingPhiSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, dphiAngle}); + spectra.add("hTrackingEtaSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, detaTracks}); + spectra.add("hTrackingPtResolutionPt", "#it{p}_{T} distribution", kTH2F, {pTTrack, pTRes}); + + spectra.add("hNTracksPerCollision", "Pocet", kTH1F, {{1000, 0., 1000., "Pocet Eventu"}}); + + spectra.add("CentralityC", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); + spectra.add("CentralityM", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); + spectra.add("AllTracksPtCent", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + } + } + + //------------------------------------------------------------------------------ template void fillHistograms(Collision const& collision, Jets const& jets, - Tracks const& tracks) + Tracks const& tracks, float weight = 1.) { - if (skipEvent(collision)) { - return; - } + const float randomConeDistanceFactor = 2.; + const int maxRandomConeIterations = 1000; - std::vector SigTrackPhi; - std::vector SigTrackEta; - std::vector RefTrackPhi; - std::vector RefTrackEta; + std::vector sigTrackPhi; + std::vector sigTrackEta; + std::vector refTrackPhi; + std::vector refTrackEta; float multFT0A = collision.multFT0A(); float multFT0C = collision.multFT0C(); - // float multZNA = collision.multZNA(); - // float multZNC = collision.multZNC(); + float centralityM = collision.centFT0M(); - spectra.fill(HIST("hMultFT0A"), multFT0A); - spectra.fill(HIST("hMultFT0C"), multFT0C); + spectra.fill(HIST("hMultFT0A"), multFT0A, centralityM, weight); + spectra.fill(HIST("hMultFT0C"), multFT0C, centralityM, weight); float jetR2 = jetR * jetR; float rho = collision.rho(); - spectra.fill(HIST("hRho"), rho); + spectra.fill(HIST("hRho"), rho, weight); int i = 0; for (const auto& track : tracks) { @@ -278,66 +317,90 @@ struct TrackJetSpectra { auto trackPhi = track.phi(); auto trackEta = track.eta(); - spectra.fill(HIST("hTrackPt"), trackPt); - spectra.fill(HIST("hTrackPhi"), trackPhi); - spectra.fill(HIST("hTrackEta"), trackEta); + spectra.fill(HIST("hTrackPt"), trackPt, centralityM, weight); + spectra.fill(HIST("hTrackPhi"), trackPhi, weight); + spectra.fill(HIST("hTrackEta"), trackEta, weight); - spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); - spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); + spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi, weight); + spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta, weight); - spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); + spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta, weight); - if ((SignalTriggerMin <= trackPt) && (trackPt <= SignalTriggerMax)) { - SigTrackPhi.push_back(trackPhi); - SigTrackEta.push_back(trackEta); + if ((signalTriggerMin <= trackPt) && (trackPt <= signalTriggerMax)) { + sigTrackPhi.push_back(trackPhi); + sigTrackEta.push_back(trackEta); } - if ((ReferenceTriggerMin <= trackPt) && (trackPt <= ReferenceTriggerMax)) { - RefTrackPhi.push_back(trackPhi); - RefTrackEta.push_back(trackEta); + if ((referenceTriggerMin <= trackPt) && (trackPt <= referenceTriggerMax)) { + refTrackPhi.push_back(trackPhi); + refTrackEta.push_back(trackEta); } } + spectra.fill(HIST("hRhovsNTracks"), i, rho, weight); + spectra.fill(HIST("hRhovsCentrality"), centralityM, rho, weight); - spectra.fill(HIST("hRhovsNTracks"), i, rho); - - float PerpConePhi = -99; - float PhiTT = -999; // FK PSAT DO KODU KOMENTARE - float EtaTT = -999; + float perpConePhi = -99; + float phiTT = -999; // this will trigger track phi + float etaTT = -999; // trigger track eta float rnd = rand->Rndm(); - bool analyzeSignal = 0; + bool analyzeSignal = 0; // 0= reference TT and 1= signal TT - if (rnd < SigToRefFraction) { + if (rnd < sigToRefFraction) { analyzeSignal = 1; } - if (analyzeSignal == 0 && RefTrackPhi.size() > 0) { + if (analyzeSignal == 0 && refTrackPhi.size() > 0) { - int ii = rand->Integer(RefTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 0.5); - spectra.fill(HIST("hPocetReferenceTriggeru"), (float)RefTrackPhi.size()); - PhiTT = RefTrackPhi[ii]; - EtaTT = RefTrackEta[ii]; + int ii = rand->Integer(refTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 0.5, centralityM, weight); + spectra.fill(HIST("hPocetReferenceTriggeru"), static_cast(refTrackPhi.size()), weight); + phiTT = refTrackPhi[ii]; + etaTT = refTrackEta[ii]; + } else if (analyzeSignal == 1 && sigTrackPhi.size() > 0) { + + int ii = rand->Integer(sigTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 1.5, centralityM, weight); + spectra.fill(HIST("hPocetSignalTriggeru"), static_cast(sigTrackPhi.size()), weight); + phiTT = sigTrackPhi[ii]; + etaTT = sigTrackEta[ii]; } - else if (analyzeSignal == 1 && SigTrackPhi.size() > 0) { + spectra.fill(HIST("hPocetTracku"), i, weight); - int ii = rand->Integer(SigTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 1.5); - spectra.fill(HIST("hPocetSignalTriggeru"), (float)SigTrackPhi.size()); - PhiTT = SigTrackPhi[ii]; - EtaTT = SigTrackEta[ii]; - } + for (const auto& jet : jets) { + // jet spectra before TT selection + auto jetPt = jet.pt(); - spectra.fill(HIST("hPocetTracku"), i); + auto jetPhi = jet.phi(); + auto jetEta = jet.eta(); + float jetArea = jet.area(); + float jetPtCorr = jetPt - rho * jetArea; - if (PhiTT < -100) { - return; + spectra.fill(HIST("hJetPtCorr"), jetPtCorr, weight); + spectra.fill(HIST("hJetPt"), jetPt, weight); + spectra.fill(HIST("hJetPhi"), jetPhi, weight); + spectra.fill(HIST("hJetEta"), jetEta, weight); + + spectra.fill(HIST("hJetPtPhi"), jetPt, jetPhi, weight); + spectra.fill(HIST("hJetPtEta"), jetPt, jetEta, weight); + + spectra.fill(HIST("hJetPtPhiEta"), jetPt, jetPhi, jetEta, weight); + + spectra.fill(HIST("hjetArea"), jetArea, weight); + spectra.fill(HIST("JetAreavsPt"), jetPt, jetArea, weight); + } + + const int minPhiTT = -100; // phi for TT not found + if (phiTT < minPhiTT) { + return; // trigger track was not found } - PerpConePhi = TVector2::Phi_mpi_pi(PhiTT - 0.5 * TMath::Pi()); + perpConePhi = TVector2::Phi_mpi_pi(phiTT - constants::math::PIHalf); + + float conePt = 0.; + ROOT::Math::PtEtaPhiMVector sumlv(0., 0., 0., 0.); - float ConePt = 0.; for (const auto& track : tracks) { // check whether track passes the selection flags if (skipTrack(track)) @@ -347,99 +410,81 @@ struct TrackJetSpectra { auto trackPhi = track.phi(); auto trackEta = track.eta(); - float DPhiPerp = TVector2::Phi_mpi_pi(trackPhi - PerpConePhi); - float DEtaPerp = trackEta - EtaTT; + float dPhiPerp = TVector2::Phi_mpi_pi(trackPhi - perpConePhi); + float dEtaPerp = trackEta - etaTT; - if ((DPhiPerp) * (DPhiPerp) + (DEtaPerp) * (DEtaPerp) < jetR2) { - ConePt = ConePt + trackPt; // FK KVULI E SCHEM BY SE MELY SCITAT 4vektory + if ((dPhiPerp) * (dPhiPerp) + (dEtaPerp) * (dEtaPerp) < jetR2) { + ROOT::Math::PtEtaPhiMVector lv(trackPt, trackEta, trackPhi, pionMass); + sumlv += lv; } } - - float CorrConePt = ConePt - TMath::Pi() * jetR2 * rho; + conePt = static_cast(sumlv.Pt()); + // calculate delta pT from perpendicular cone + float corrConeDeltaPt = conePt - constants::math::PI * jetR2 * rho; if (analyzeSignal == 0) { - spectra.fill(HIST("hRefCorrConePt"), CorrConePt); + spectra.fill(HIST("hRefCorrConePt"), corrConeDeltaPt, weight); } else { - spectra.fill(HIST("hSigCorrConePt"), CorrConePt); + spectra.fill(HIST("hSigCorrConePt"), corrConeDeltaPt, weight); } int jj = 0; - float Jet1Phi = 0.; - float Jet1Eta = 0.; - float Jet2Phi = 0.; - float Jet2Eta = 0.; + const int jet1 = 1; + const int jet2 = 2; + float jet1Phi = 0.; + float jet1Eta = 0.; + float jet2Phi = 0.; + float jet2Eta = 0.; for (const auto& jet : jets) { jj++; - auto jetPt = jet.pt(); - auto jetPhi = jet.phi(); auto jetEta = jet.eta(); - float jetArea = jet.area(); - float jetPtCorr = jetPt - rho * jetArea; - if (jj == 1) { - Jet1Phi = jetPhi; - Jet1Eta = jetEta; + if (jj == jet1) { + jet1Phi = jetPhi; + jet1Eta = jetEta; } - if (jj == 2) { - Jet2Phi = jetPhi; - Jet2Eta = jetEta; - } - - // FK TATO SPEKTRA SE PLNI JEN KDYZ JE TRIGGER. LEPE BY BYLO PLNIT SPEKTRA INKLUSIVNE - - spectra.fill(HIST("hJetPtCorr"), jetPtCorr); - spectra.fill(HIST("hJetPt"), jetPt); - spectra.fill(HIST("hJetPhi"), jetPhi); - spectra.fill(HIST("hJetEta"), jetEta); - - spectra.fill(HIST("hJetPtPhi"), jetPt, jetPhi); - spectra.fill(HIST("hJetPtEta"), jetPt, jetEta); - - spectra.fill(HIST("hJetPtPhiEta"), jetPt, jetPhi, jetEta); - - spectra.fill(HIST("hjetArea"), jetArea); - spectra.fill(HIST("JetAreavsPt"), jetPt, jetArea); - - float DPhi = -100; - DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetPhi - PhiTT)); - - if (DPhi > TMath::Pi() - DPhiCut) { - if (analyzeSignal == 0) { - spectra.fill(HIST("hRecoilJetRefPt"), jetPt); - spectra.fill(HIST("hRecoilJetRefCorrPt"), jetPtCorr); - } else { - spectra.fill(HIST("hRecoilJetSigPt"), jetPt); - spectra.fill(HIST("hRecoilJetSigCorrPt"), jetPtCorr); - } + if (jj == jet2) { + jet2Phi = jetPhi; + jet2Eta = jetEta; } } - // printf("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"); bool bCloseJet = true; float randJetPhi = -999.; float randJetEta = -999.; - while (bCloseJet) { // FK dat nejake pocitadlo, ktere umozni opustit loop - randJetPhi = rand->Uniform(-TMath::Pi(), TMath::Pi()); - randJetEta = rand->Uniform(-0.5, 0.5); + int iii = 0; - float vphi1 = TVector2::Phi_mpi_pi(randJetPhi - Jet1Phi); - float vphi2 = TVector2::Phi_mpi_pi(randJetPhi - Jet2Phi); - float veta1 = randJetEta - Jet1Eta; - float veta2 = randJetEta - Jet2Eta; - float dist1 = sqrt(vphi1 * vphi1 + veta1 * veta1); - float dist2 = sqrt(vphi2 * vphi2 + veta2 * veta2); + while (bCloseJet) { + iii++; + if (iii > maxRandomConeIterations) { + break; + } + + randJetPhi = rand->Uniform(-constants::math::PI, constants::math::PI); + randJetEta = rand->Uniform(-0.5, 0.5); - if (dist1 > 2 * jetR && dist2 > 2 * jetR) + float vphi1 = TVector2::Phi_mpi_pi(randJetPhi - jet1Phi); + float vphi2 = TVector2::Phi_mpi_pi(randJetPhi - jet2Phi); + float vphiTT = TVector2::Phi_mpi_pi(randJetPhi - phiTT); + float veta1 = randJetEta - jet1Eta; + float veta2 = randJetEta - jet2Eta; + float vetaTT = randJetEta - etaTT; + float dist1 = std::sqrt(vphi1 * vphi1 + veta1 * veta1); + float dist2 = std::sqrt(vphi2 * vphi2 + veta2 * veta2); + float distTT = std::sqrt(vphiTT * vphiTT + vetaTT * vetaTT); + + if (dist1 > randomConeDistanceFactor * jetR && + dist2 > randomConeDistanceFactor * jetR && + distTT > randomConeDistanceFactor * jetR) bCloseJet = false; } - // printf("yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n"); - - float RandConePt = 0.; + float randConePt = 0.; + sumlv = ROOT::Math::PtEtaPhiMVector(0., 0., 0., 0.); for (const auto& track : tracks) { if (skipTrack(track)) continue; @@ -447,50 +492,76 @@ struct TrackJetSpectra { auto trackPt = track.pt(); auto trackPhi = track.phi(); auto trackEta = track.eta(); - float DPhiRand = TVector2::Phi_mpi_pi(trackPhi - randJetPhi); - float DEtaRand = trackEta - randJetEta; + float dPhiRand = TVector2::Phi_mpi_pi(trackPhi - randJetPhi); + float dEtaRand = trackEta - randJetEta; - if ((DPhiRand) * (DPhiRand) + (DEtaRand) * (DEtaRand) < jetR2) { - RandConePt = RandConePt + trackPt; // FK scitat 4momenty + if ((dPhiRand) * (dPhiRand) + (dEtaRand) * (dEtaRand) < jetR2) { + ROOT::Math::PtEtaPhiMVector lv(trackPt, trackEta, trackPhi, pionMass); + sumlv += lv; } } + randConePt = static_cast(sumlv.Pt()); - float CorrRandConePt = RandConePt - TMath::Pi() * jetR2 * rho; + float corrRandConeDeltaPt = randConePt - constants::math::PI * jetR2 * rho; if (analyzeSignal == 0) { - spectra.fill(HIST("hRefRandCorrConePt"), CorrRandConePt); + spectra.fill(HIST("hRefRandCorrConePt"), corrRandConeDeltaPt, centralityM, weight); } else { - spectra.fill(HIST("hSigRandCorrConePt"), CorrRandConePt); + spectra.fill(HIST("hSigRandCorrConePt"), corrRandConeDeltaPt, centralityM, weight); + } + + // Recoil jet spectra + for (const auto& jet : jets) { + auto jetPt = jet.pt(); + auto jetPhi = jet.phi(); + float jetArea = jet.area(); + float jetPtCorr = jetPt - rho * jetArea; + + float dPhi = -100; + dPhi = std::fabs(TVector2::Phi_mpi_pi(jetPhi - phiTT)); + + if (dPhi > constants::math::PI - dPhiCut) { + if (analyzeSignal == 0) { + spectra.fill(HIST("hRecoilJetRefPt"), jetPt, centralityM, weight); + spectra.fill(HIST("hRecoilJetRefCorrPt"), jetPtCorr, centralityM, weight); + } else { + spectra.fill(HIST("hRecoilJetSigPt"), jetPt, centralityM, weight); + spectra.fill(HIST("hRecoilJetSigCorrPt"), jetPtCorr, centralityM, weight); + } + } } } + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - template + // template + template void fillMatchedHistograms(JTracksTable const& tracks, JetsBase const& jetsBase, JetsTag const& jetsTag, float weight = 1.) { - std::vector SigTrackPhi; - double PhiTT = 0.0; + + std::vector sigTrackPhi; + double phiTT = 0.0; for (const auto& track : tracks) { if (skipTrack(track)) continue; - - if ((SignalTriggerMin <= trackPt) && (trackPt <= SignalTriggerMax)) - SigTrackPhi.push_back(track.phi()); + if ((signalTriggerMin <= track.pt()) && (track.pt() <= signalTriggerMax)) + sigTrackPhi.push_back(track.phi()); } - bool bIsThereTTSig = SigTrackPhi.size() > 0; + + bool bIsThereTTSig = sigTrackPhi.size() > 0; if (bIsThereTTSig) - PhiTT = [rand->Integer(SigTrackPhi.size())]; + phiTT = sigTrackPhi[rand->Integer(sigTrackPhi.size())]; for (const auto& jetBase : jetsBase) { - bool bIsBaseJetRecoil = false; + bool bIsBaseJetRecoil = false; /////////////////////////////////////////////////////////////////////////////////////////////////// if (bIsThereTTSig) { - float DPhi = TMath::Abs(TVector2::Phi_mpi_pi(jetBase.phi() - PhiTT)); - if (DPhi > TMath::Pi() - DPhiCut) + float dPhi = std::fabs(TVector2::Phi_mpi_pi(jetBase.phi() - phiTT)); + if (dPhi > constants::math::PI - dPhiCut) bIsBaseJetRecoil = true; } @@ -498,105 +569,242 @@ struct TrackJetSpectra { } } - void processCollisions(aod::JetCollisions::iterator const& collision) - { // no filtering on collisions - - spectra.fill(HIST("hEventSelectionCount"), 0.5); // all events without cuts + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + void processFilteredCollisions(soa::Filtered::iterator const& collision) + { // check whether event contains the required flag for event selection (sel8 in this case) if (skipEvent(collision)) return; - spectra.fill(HIST("hEventSelectionCount"), 1.5); // number of events after applying event selection - spectra.fill(HIST("hVertexZ_NoCut"), collision.posZ()); + spectra.fill(HIST("hVertexZ_EventFiltering"), collision.posZ()); // compare with "hVertexZ_Cut" histogram + } + + PROCESS_SWITCH(TrackJetSpectra, processFilteredCollisions, "process filtered collisions", false); + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - // Imperative way to apply z-vertex cut (ineffective way, much faster is to apply the filter) - if (fabs(collision.posZ()) > vertexZCut) { + void processJets(FilteredColl const& collision, + soa::Filtered const& jets, + soa::Filtered const& tracks) + { + if (skipEvent(collision)) { return; } - spectra.fill(HIST("hEventSelectionCount"), 2.5); // number of events after applying event selection + z-vertex cut - spectra.fill(HIST("hVertexZ_Cut"), collision.posZ()); + // check whether event contains the required flag for event selection (sel8 in this case) + + fillHistograms(collision, jets, tracks); } - PROCESS_SWITCH(TrackJetSpectra, processCollisions, "process collisions", true); - void processFilteredCollisions(soa::Filtered::iterator const& collision) + PROCESS_SWITCH(TrackJetSpectra, processJets, "process inclusive jets", false); + + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + void processJetsMCDet(FilteredColl const& collision, + FilteredJetsDetLevel const& jets, + soa::Filtered const& tracks) { // check whether event contains the required flag for event selection (sel8 in this case) - if (skipEvent(collision)) + if (skipEvent(collision)) { return; + } + fillHistograms(collision, jets, tracks); + } - spectra.fill(HIST("hVertexZ_EventFiltering"), collision.posZ()); // compare with "hVertexZ_Cut" histogram + PROCESS_SWITCH(TrackJetSpectra, processJetsMCDet, "process MCDet jets", false); + + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + void processJetsMCDetWeighted(FilteredCollDetLevelGetWeight const& collision, + FilteredJetsDetLevel const& jets, + soa::Filtered const& tracks) + { + if (skipEvent(collision) || collision.isOutlier()) { + return; + } + // check whether event contains the required flag for event selection (sel8 in this case) + auto weight = collision.weight(); + fillHistograms(collision, jets, tracks, weight); } - PROCESS_SWITCH(TrackJetSpectra, processFilteredCollisions, "process filtered collisions", false); - void processTracks(soa::Filtered::iterator const& collision, - soa::Filtered const& tracks) + PROCESS_SWITCH(TrackJetSpectra, processJetsMCDetWeighted, "process MCDet jets", false); + + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + void processMCPartLevel(FilteredCollPartLevelMB const& collision, + FilteredParticles const& particles, + FilteredJetsPartLevel const& jets) { // check whether event contains the required flag for event selection (sel8 in this case) if (skipEvent(collision)) return; - int i = 0; - int PocetSigTrigeru = 0; - int PocetRefTrigeru = 0; - for (const auto& track : tracks) { - // check whether track passes the selection flags - if (skipTrack(track)) - continue; - i++; - auto trackPt = track.pt(); - auto trackPhi = track.phi(); - auto trackEta = track.eta(); + fillMCPHistograms(collision, jets, particles); + } - spectra.fill(HIST("hTrackPt"), trackPt); - spectra.fill(HIST("hTrackPhi"), trackPhi); - spectra.fill(HIST("hTrackEta"), trackEta); + PROCESS_SWITCH(TrackJetSpectra, processMCPartLevel, "process MCDet jets", false); - spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi); - spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta); + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta); + void processMCPartLevelWeighted(FilteredCollPartLevel const& collision, + FilteredParticles const& particles, + FilteredJetsPartLevel const& jets) + { + // check whether event contains the required flag for event selection (sel8 in this case) + if (skipEvent(collision) || collision.isOutlier()) + return; + + auto weight = collision.weight(); + fillMCPHistograms(collision, jets, particles, weight); + } - if ((SignalTriggerMin <= trackPt) && (trackPt <= SignalTriggerMax)) - PocetSigTrigeru++; + PROCESS_SWITCH(TrackJetSpectra, processMCPartLevelWeighted, "process MCDet jets", false); - if ((ReferenceTriggerMin <= trackPt) && (trackPt <= ReferenceTriggerMax)) - PocetRefTrigeru++; - } + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - spectra.fill(HIST("hPocetReferenceTriggeru"), PocetRefTrigeru); - spectra.fill(HIST("hPocetSignalTriggeru"), PocetSigTrigeru); - spectra.fill(HIST("hPocetTracku"), i); + void processTrackEfficiency(CollPartLevelEfficiencyWeighted const& collisionMC, + CollisionMCD const& collision, + TracksMCDetFullTable const& tracks, + ParticlesFullTable const& mcParticles) + { + if (collisionMC.isOutlier()) + return; + auto weight = collisionMC.weight(); + + fillEfficiency(collisionMC, + collision, + tracks, + mcParticles, + weight); } - PROCESS_SWITCH(TrackJetSpectra, processTracks, "process tracks", false); + PROCESS_SWITCH(TrackJetSpectra, processTrackEfficiency, "process efficiency of tracks", false); - void processJets(FilteredColl const& collision, - soa::Filtered const& jets, - soa::Filtered const& tracks) + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + void processTrackEfficiencyMB(CollPartLevelMBEfficiency const& collisionMC, + CollisionMCD const& collision, + TracksMCDetFullTable const& tracks, + ParticlesFullTable const& mcParticles) { - // check whether event contains the required flag for event selection (sel8 in this case) + // if (skipEvent(collision)) return; - fillHistograms(collision, jets, tracks); + fillEfficiency(collisionMC, + collision, + tracks, + mcParticles); } + PROCESS_SWITCH(TrackJetSpectra, processTrackEfficiencyMB, "process efficiency of tracks", false); - PROCESS_SWITCH(TrackJetSpectra, processJets, "process inclusive jets", false); + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + template + void fillEfficiency(JCollisionMC const& collisionMC, + JCollision const& collisions, + JTracks const& tracks, + JMcParticles const& mcParticles, + float weight = 1.) - void processJetsMCDet(FilteredColl const& collision, - FilteredJetsDetLevel const& jets, - soa::Filtered const& tracks) { - // check whether event contains the required flag for event selection (sel8 in this case) - fillHistograms(collision, jets, tracks); + if (!(std::fabs(collisionMC.posZ()) < vertexZCut)) { + return; + } + + if (collisions.size() < 1) { + return; + } + + if (!jetderiveddatautilities::selectCollision(collisions.begin(), eventSelectionBits, skipMBGapEvents)) { // Skipping MC events that have their first associated collision not reconstructed + return; + } + + float centralityC = collisions.begin().centFT0C(); + + float centralityM = collisions.begin().centFT0M(); + + spectra.fill(HIST("CentralityC"), centralityC, weight); + + spectra.fill(HIST("CentralityM"), centralityM, weight); + + for (auto const& particle : mcParticles) { + auto pdgParticle = pdg->GetParticle(particle.pdgCode()); + if (!pdgParticle) + continue; + + if (static_cast(pdgParticle->Charge()) == 0) + continue; + if (!particle.isPhysicalPrimary()) + continue; + + if (std::fabs(particle.eta()) > trkEtaCut) + continue; + if (particle.pt() < trkPtMin) + continue; + + spectra.fill(HIST("hTrackingEfficiencyDenominatorPt"), particle.pt(), centralityM, weight); + } + + for (auto const& collision : collisions) { + if (skipEvent(collision)) + continue; + if (!(std::fabs(collision.posZ()) < vertexZCut)) + continue; + + auto collTracks = tracks.sliceBy(tracksPerJCollision, collision.globalIndex()); + spectra.fill(HIST("hNTracksPerCollision"), collTracks.size()); + // for (auto const& particle : particles){ + + for (auto const& track : collTracks) { + if (skipTrack(track)) + continue; + + if (std::fabs(track.eta()) > trkEtaCut) + continue; + if (track.pt() < trkPtMin) + continue; + + spectra.fill(HIST("AllTracksPtCent"), track.pt(), centralityM, weight); + + if (!track.has_mcParticle()) + continue; + + auto mcPart = track.template mcParticle_as(); + + auto pdgParticle = pdg->GetParticle(mcPart.pdgCode()); + if (static_cast(pdgParticle->Charge()) == 0) + continue; + + if (std::fabs(mcPart.eta()) > trkEtaCut) + continue; + if (mcPart.pt() < trkPtMin) + continue; + + if (!mcPart.isPhysicalPrimary()) { + spectra.fill(HIST("hNonprimaryParticlesPt"), track.pt(), weight); + continue; + } + spectra.fill(HIST("hTrackingEfficiencyNumeratorPt"), mcPart.pt(), centralityM, weight); + + float dPhi = TVector2::Phi_mpi_pi(mcPart.phi() - track.phi()); + float dEta = mcPart.eta() - track.eta(); + float dPtResolution = (mcPart.pt() - track.pt()) / mcPart.pt(); + + spectra.fill(HIST("hTrackingPhiSmearingPt"), mcPart.pt(), dPhi, weight); + spectra.fill(HIST("hTrackingEtaSmearingPt"), mcPart.pt(), dEta, weight); + spectra.fill(HIST("hTrackingPtResolutionPt"), mcPart.pt(), dPtResolution, weight); + } + } } + //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + template + void fillMCPHistograms(Collision const& collision, Jets const& jets, + Particles const& particles, float weight = 1.) - void processMCPartLevel(FilteredCollPartLevel const& collision, - FilteredParticles const& particles, - FilteredJetsPartLevel const& jets) { - spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5); + + spectra.fill(HIST("hEventSelectionCountPartLevel"), 0.5, weight); std::vector vPhiOfTT; @@ -604,9 +812,8 @@ struct TrackJetSpectra { bool analyzeSignal = 0; float rho = collision.rho(); - if (rnd < SigToRefFraction) { + if (rnd < sigToRefFraction) analyzeSignal = 1; - } for (const auto& particle : particles) { auto pdgParticle = pdg->GetParticle(particle.pdgCode()); @@ -621,21 +828,22 @@ struct TrackJetSpectra { float particlePt = particle.pt(); float particlePhi = particle.phi(); - if (analyzeSignal && (particlePt > SignalTriggerMin && particlePt < SignalTriggerMax)) { + if (analyzeSignal && (particlePt > signalTriggerMin && particlePt < signalTriggerMax)) { vPhiOfTT.push_back(particlePhi); } - if (!analyzeSignal && (particlePt > ReferenceTriggerMin && particlePt < ReferenceTriggerMax)) { + if (!analyzeSignal && (particlePt > referenceTriggerMin && particlePt < referenceTriggerMax)) { vPhiOfTT.push_back(particlePhi); } } - int ii = -1; + + int ii = -1; // index of selected particle level trigger track if (vPhiOfTT.size() > 0) { ii = rand->Integer(vPhiOfTT.size()); if (analyzeSignal == 0) { - spectra.fill(HIST("hTTCountPartLevel"), 0.5); + spectra.fill(HIST("hTTCountPartLevel"), 0.5, weight); } else { - spectra.fill(HIST("hTTCountPartLevel"), 1.5); + spectra.fill(HIST("hTTCountPartLevel"), 1.5, weight); } } @@ -645,27 +853,28 @@ struct TrackJetSpectra { float jetArea = jet.area(); float jetPtCorr = jetPt - rho * jetArea; - spectra.fill(HIST("hJetPtEtaPhiRhoArea_Part"), jetPt, jet.eta(), jet.phi(), rho, jetArea); + spectra.fill(HIST("hJetPtEtaPhiRhoArea_Part"), jetPt, jet.eta(), jet.phi(), rho, jetArea, weight); + spectra.fill(HIST("hJetPtMCP"), jetPt, weight); - if (ii > -1) { + if (ii > -1) { // only events with TT particle level - float PhiTT = vPhiOfTT[ii]; + float phiTT = vPhiOfTT[ii]; - float DeltaPhi = TMath::Abs(TVector2::Phi_mpi_pi(PhiTT - jetPhi)); - if (DeltaPhi > TMath::Pi() - DPhiCut) { + float deltaPhi = std::fabs(TVector2::Phi_mpi_pi(phiTT - jetPhi)); + if (deltaPhi > constants::math::PI - dPhiCut) { if (analyzeSignal == 0) { - spectra.fill(HIST("hRecoilJetRefPtMCP"), jetPt); - spectra.fill(HIST("hRecoilJetRefCorrPtMCP"), jetPtCorr); + spectra.fill(HIST("hRecoilJetRefPtMCP"), jetPt, weight); + spectra.fill(HIST("hRecoilJetRefCorrPtMCP"), jetPtCorr, weight); } else { - spectra.fill(HIST("hRecoilJetSigPtMCP"), jetPt); - spectra.fill(HIST("hRecoilJetSigCorrPtMCP"), jetPtCorr); + spectra.fill(HIST("hRecoilJetSigPtMCP"), jetPt, weight); + spectra.fill(HIST("hRecoilJetSigCorrPtMCP"), jetPtCorr, weight); } } } } } - PROCESS_SWITCH(TrackJetSpectra, processJetsMCDet, "process inclusive jets", false); + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ void processJetsMatched(FilteredCollDetLevelGetWeight const& collision, aod::JetMcCollisions const&, @@ -673,7 +882,7 @@ struct TrackJetSpectra { FilteredMatchedJetsDetLevel const& mcdjets, FilteredMatchedJetsPartLevel const& mcpjets) { - if (skipEvent(collision)) + if (skipEvent(collision) || collision.isOutlier()) return; auto mcpjetsPerMCCollision = mcpjets.sliceBy(partJetsPerCollision, collision.mcCollisionId()); @@ -682,24 +891,40 @@ struct TrackJetSpectra { } PROCESS_SWITCH(TrackJetSpectra, processJetsMatched, "process matching of MC jets (no weight)", false); - //------------------------------------------------------------------------------ + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Auxiliary functions + template bool skipEvent(const Collision& coll) { /// \brief: trigger cut is needed for pp data + return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits, skipMBGapEvents); + } + + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + template + bool skipMCEvent(const Collision& coll) + { return !jetderiveddatautilities::selectCollision(coll, eventSelectionBits); } + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + template bool skipTrack(const Track& track) { + + // check track quality select global tracks return !jetderiveddatautilities::selectTrack(track, trackSelection); } + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + template bool isJetWithHighPtConstituent(Jet const& jet, Tracks const&) { + // kill all jets which have a constituent track with pT > 100 GeV bool bIsJetWithHighPtConstituent = false; for (const auto& jetConstituent : jet.template tracks_as()) { if (jetConstituent.pt() > maxJetConstituentPt) { @@ -710,15 +935,15 @@ struct TrackJetSpectra { return bIsJetWithHighPtConstituent; } + //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + template void dataForUnfolding(PartJet const& partJet, DetJet const& detJets, bool bIsBaseJetRecoil, TracksTable const& tracks, float weight = 1.) { - + // function which matches particle jet with detector level jet float partJetPt = partJet.pt(); bool bIsThereMatchedJet = partJet.has_matchedJetGeo(); - // FK mame histogram particle level pT - if (bIsThereMatchedJet) { const auto& jetsMatched = partJet.template matchedJetGeo_as>(); @@ -729,8 +954,10 @@ struct TrackJetSpectra { if (skipMatchedDetJet) { // Miss jets spectra.fill(HIST("hMissedJets_pT"), partJetPt, weight); + if (bIsBaseJetRecoil) spectra.fill(HIST("hMissedJets_pT_RecoilJets"), partJetPt, weight); + } else { float detJetPt = jetMatched.pt(); @@ -745,20 +972,18 @@ struct TrackJetSpectra { } } } - } - // template - // bool isJetWithHighPtConstituent(Jet const& jet, Tracks const&) - // { - // bool bIsJetWithHighPtConstituent = false; - // for (const auto& jetConstituent : jet.template tracks_as()) { - // if (jetConstituent.pt() > maxJetConstituentPt) { - // bIsJetWithHighPtConstituent = true; - // break; - // } - // } - // return bIsJetWithHighPtConstituent; - // } + for (const auto& jetDet : detJets) { + if(isJetWithHighPtConstituent(jetDet, tracks)) + continue; + + auto detJetPt = jetDet.pt(); + spectra.fill(HIST("hDetLevelInclusiveJetsPt"), detJetPt, weight); + if (!jetDet.has_matchedJetGeo()) { + spectra.fill(HIST("hFakeInclusiveJetsPt"), detJetPt, weight); + } + } + } }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) From 7860de0c9100ecf9127b225c9dc54fc7a634e66c Mon Sep 17 00:00:00 2001 From: fkrizek Date: Tue, 26 May 2026 21:03:42 +0200 Subject: [PATCH 4/5] Address comments --- PWGJE/Tasks/trackJetSpectra.cxx | 302 ++++++++++++++++---------------- 1 file changed, 151 insertions(+), 151 deletions(-) diff --git a/PWGJE/Tasks/trackJetSpectra.cxx b/PWGJE/Tasks/trackJetSpectra.cxx index dec02c25020..7bc5f08dc09 100644 --- a/PWGJE/Tasks/trackJetSpectra.cxx +++ b/PWGJE/Tasks/trackJetSpectra.cxx @@ -21,11 +21,11 @@ #include "Common/Core/RecoDecay.h" #include "Common/DataModel/Multiplicity.h" -#include "CommonConstants/MathConstants.h" -#include "Framework/ASoA.h" -#include "Framework/AnalysisTask.h" -#include "Framework/HistogramRegistry.h" -#include "Framework/O2DatabasePDGPlugin.h" +#include +#include +#include +#include +#include #include #include #include @@ -33,7 +33,7 @@ #include #include -#include "TRandom3.h" +#include #include #include #include @@ -123,7 +123,7 @@ struct TrackJetSpectra { //------------------------------------------------------------ - TRandom3* rand = new TRandom3(0); + TRandom3 rand = TRandom3(0); // Declare filter on collision Z vertex Filter collisionFilter = nabs(aod::jcollision::posZ) < vertexZCut; Filter collisionFilterMC = nabs(aod::jmccollision::posZ) < vertexZCut; @@ -185,188 +185,188 @@ struct TrackJetSpectra { // Disitribution of tracks if (doprocessJetsMCDet || doprocessJetsMCDetWeighted || doprocessJets) { - spectra.add("hPocetTracku", "Pocet", kTH1F, {{1000, 0., 1000., "Pocet Eventu"}}); - spectra.add("hPocetSignalTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hPocetReferenceTriggeru", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); - spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); - spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); - spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Pocet Eventu"}, centrality}); - spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH2F, {pT, centrality}); - spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); - spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); + spectra.add("hNumberOfTracks", "Number", kTH1F, {{1000, 0., 1000., "Number of Events"}}); + spectra.add("hNumberOfSignalTriggers", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); + spectra.add("hNumberOfReferenceTriggers", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); + spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH2F, {pT, centrality}); + spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); + spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); - spectra.add("hTrackPtPhi", "#it{p}_{T} vs. #varphi distribution of tracks", kTH2F, {pT, phiAngle}); - spectra.add("hTrackPtEta", "#it{p}_{T} vs. #eta distribution of tracks", kTH2F, {pT, etaTracks}); + spectra.add("hTrackPtPhi", "#it{p}_{T} vs. #varphi distribution of tracks", kTH2F, {pT, phiAngle}); + spectra.add("hTrackPtEta", "#it{p}_{T} vs. #eta distribution of tracks", kTH2F, {pT, etaTracks}); - spectra.add("hTrackPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of tracks", kTH3F, {pT, phiAngle, etaTracks}); + spectra.add("hTrackPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of tracks", kTH3F, {pT, phiAngle, etaTracks}); - // Distribution of jets - spectra.add("hJetPt", "#it{p}_{T} distribution of jets", kTH1F, {pT}); - spectra.add("hJetPhi", "#varphi distribution of jets", kTH1F, {phiAngle}); - spectra.add("hJetEta", "#eta distribution of jets", kTH1F, {etaJets}); + // Distribution of jets + spectra.add("hJetPt", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + spectra.add("hJetPhi", "#varphi distribution of jets", kTH1F, {phiAngle}); + spectra.add("hJetEta", "#eta distribution of jets", kTH1F, {etaJets}); - spectra.add("hJetPtPhi", "#it{p}_{T} vs. #varphi distribution of jets", kTH2F, {pT, phiAngle}); - spectra.add("hJetPtEta", "#it{p}_{T} vs. #eta distribution of jets", kTH2F, {pT, etaJets}); + spectra.add("hJetPtPhi", "#it{p}_{T} vs. #varphi distribution of jets", kTH2F, {pT, phiAngle}); + spectra.add("hJetPtEta", "#it{p}_{T} vs. #eta distribution of jets", kTH2F, {pT, etaJets}); - spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); + spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); - spectra.add("hMultFT0A", "Mult. signal from FTOA", kTH2F, {{2000, 0.0, 40000., "FT0A"}, centrality}); - spectra.add("hMultFT0C", "Mult. signal from FTOC", kTH2F, {{2000, 0.0, 40000., "FT0C"}, centrality}); + spectra.add("hMultFT0A", "Mult. signal from FTOA", kTH2F, {{2000, 0.0, 40000., "FT0A"}, centrality}); + spectra.add("hMultFT0C", "Mult. signal from FTOC", kTH2F, {{2000, 0.0, 40000., "FT0C"}, centrality}); - spectra.add("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + spectra.add("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); - spectra.add("hRho", "distribution of rho", kTH1F, {rho}); - spectra.add("hjetArea", "distribution of jet area", kTH1F, {jetArea}); + spectra.add("hRho", "distribution of rho", kTH1F, {rho}); + spectra.add("hjetArea", "distribution of jet area", kTH1F, {jetArea}); - spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); - spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); - spectra.add("hRhovsCentrality", "Rho vs number of tracks", kTH2F, {centrality, rho}); + spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); + spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); + spectra.add("hRhovsCentrality", "Rho vs number of tracks", kTH2F, {centrality, rho}); - spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); - spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); + spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); + spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); - spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH2F, {pT, centrality}); - spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH2F, {pT, centrality}); + spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH2F, {pT, centrality}); + spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH2F, {pT, centrality}); - spectra.add("hTTCountData", "Pocet", kTH2F, {{2, 0., 2., "Pocet TT Data"}, centrality}); - } + spectra.add("hTTCountData", "Number", kTH2F, {{2, 0., 2., "Number TT Data"}, centrality}); + } - if (doprocessJetsMatched) { - spectra.add("hDetLevelInclusiveJetsPt", "All reconstructed inclusive jets", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hFakeInclusiveJetsPt", "Det. level inclusive jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + if (doprocessJetsMatched) { + spectra.add("hDetLevelInclusiveJetsPt", "All reconstructed inclusive jets", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hFakeInclusiveJetsPt", "Det. level inclusive jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); - spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); + spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); - spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); - spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); - spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); - } + spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); + spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); + } - if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { - spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { + spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hEventSelectionCountPartLevel", "Pocet", kTH1F, {{10, 0., 10., "Pocet Eventu"}}); - spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + spectra.add("hEventSelectionCountPartLevel", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); + spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); - spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); - spectra.add("hJetPtMCP", "#it{p}_{T} distribution of jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); + spectra.add("hJetPtMCP", "#it{p}_{T} distribution of jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hTTCountPartLevel", "Pocet", kTH1F, {{2, 0., 2., "Pocet TT MCP"}}); - } + spectra.add("hTTCountPartLevel", "Number", kTH1F, {{2, 0., 2., "Number TT MCP"}}); + } - if (doprocessTrackEfficiency || doprocessTrackEfficiencyMB) { - spectra.add("hTrackingEfficiencyDenominatorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); - spectra.add("hNonprimaryParticlesPt", "#it{p}_{T} distribution", kTH1F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}}); - spectra.add("hTrackingEfficiencyNumeratorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + if (doprocessTrackEfficiency || doprocessTrackEfficiencyMB) { + spectra.add("hTrackingEfficiencyDenominatorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + spectra.add("hNonprimaryParticlesPt", "#it{p}_{T} distribution", kTH1F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}}); + spectra.add("hTrackingEfficiencyNumeratorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); - spectra.add("hTrackingPhiSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, dphiAngle}); - spectra.add("hTrackingEtaSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, detaTracks}); - spectra.add("hTrackingPtResolutionPt", "#it{p}_{T} distribution", kTH2F, {pTTrack, pTRes}); + spectra.add("hTrackingPhiSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, dphiAngle}); + spectra.add("hTrackingEtaSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, detaTracks}); + spectra.add("hTrackingPtResolutionPt", "#it{p}_{T} distribution", kTH2F, {pTTrack, pTRes}); - spectra.add("hNTracksPerCollision", "Pocet", kTH1F, {{1000, 0., 1000., "Pocet Eventu"}}); + spectra.add("hNTracksPerCollision", "Number", kTH1F, {{1000, 0., 1000., "Number of Events"}}); - spectra.add("CentralityC", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); - spectra.add("CentralityM", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); - spectra.add("AllTracksPtCent", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); - } - } + spectra.add("CentralityC", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); + spectra.add("CentralityM", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); + spectra.add("AllTracksPtCent", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + } + } - //------------------------------------------------------------------------------ + //------------------------------------------------------------------------------ - template - void fillHistograms(Collision const& collision, Jets const& jets, - Tracks const& tracks, float weight = 1.) + template + void fillHistograms(Collision const& collision, Jets const& jets, + Tracks const& tracks, float weight = 1.) - { + { - const float randomConeDistanceFactor = 2.; - const int maxRandomConeIterations = 1000; + const float randomConeDistanceFactor = 2.; + const int maxRandomConeIterations = 1000; - std::vector sigTrackPhi; - std::vector sigTrackEta; - std::vector refTrackPhi; - std::vector refTrackEta; + std::vector sigTrackPhi; + std::vector sigTrackEta; + std::vector refTrackPhi; + std::vector refTrackEta; - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float centralityM = collision.centFT0M(); + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float centralityM = collision.centFT0M(); - spectra.fill(HIST("hMultFT0A"), multFT0A, centralityM, weight); - spectra.fill(HIST("hMultFT0C"), multFT0C, centralityM, weight); + spectra.fill(HIST("hMultFT0A"), multFT0A, centralityM, weight); + spectra.fill(HIST("hMultFT0C"), multFT0C, centralityM, weight); - float jetR2 = jetR * jetR; - float rho = collision.rho(); + float jetR2 = jetR * jetR; + float rho = collision.rho(); - spectra.fill(HIST("hRho"), rho, weight); + spectra.fill(HIST("hRho"), rho, weight); - int i = 0; - for (const auto& track : tracks) { - // check whether track passes the selection flags - if (skipTrack(track)) - continue; - i++; - auto trackPt = track.pt(); - auto trackPhi = track.phi(); - auto trackEta = track.eta(); + int i = 0; + for (const auto& track : tracks) { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + i++; + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); - spectra.fill(HIST("hTrackPt"), trackPt, centralityM, weight); - spectra.fill(HIST("hTrackPhi"), trackPhi, weight); - spectra.fill(HIST("hTrackEta"), trackEta, weight); + spectra.fill(HIST("hTrackPt"), trackPt, centralityM, weight); + spectra.fill(HIST("hTrackPhi"), trackPhi, weight); + spectra.fill(HIST("hTrackEta"), trackEta, weight); - spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi, weight); - spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta, weight); + spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi, weight); + spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta, weight); - spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta, weight); + spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta, weight); - if ((signalTriggerMin <= trackPt) && (trackPt <= signalTriggerMax)) { - sigTrackPhi.push_back(trackPhi); - sigTrackEta.push_back(trackEta); - } + if ((signalTriggerMin <= trackPt) && (trackPt <= signalTriggerMax)) { + sigTrackPhi.push_back(trackPhi); + sigTrackEta.push_back(trackEta); + } - if ((referenceTriggerMin <= trackPt) && (trackPt <= referenceTriggerMax)) { - refTrackPhi.push_back(trackPhi); - refTrackEta.push_back(trackEta); - } - } - spectra.fill(HIST("hRhovsNTracks"), i, rho, weight); - spectra.fill(HIST("hRhovsCentrality"), centralityM, rho, weight); + if ((referenceTriggerMin <= trackPt) && (trackPt <= referenceTriggerMax)) { + refTrackPhi.push_back(trackPhi); + refTrackEta.push_back(trackEta); + } + } + spectra.fill(HIST("hRhovsNTracks"), i, rho, weight); + spectra.fill(HIST("hRhovsCentrality"), centralityM, rho, weight); - float perpConePhi = -99; - float phiTT = -999; // this will trigger track phi - float etaTT = -999; // trigger track eta - float rnd = rand->Rndm(); - bool analyzeSignal = 0; // 0= reference TT and 1= signal TT + float perpConePhi = -99; + float phiTT = -999; // this will trigger track phi + float etaTT = -999; // trigger track eta + float rnd = rand.Rndm(); + bool analyzeSignal = 0; // 0= reference TT and 1= signal TT - if (rnd < sigToRefFraction) { - analyzeSignal = 1; - } + if (rnd < sigToRefFraction) { + analyzeSignal = 1; + } - if (analyzeSignal == 0 && refTrackPhi.size() > 0) { + if (analyzeSignal == 0 && refTrackPhi.size() > 0) { - int ii = rand->Integer(refTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 0.5, centralityM, weight); - spectra.fill(HIST("hPocetReferenceTriggeru"), static_cast(refTrackPhi.size()), weight); - phiTT = refTrackPhi[ii]; - etaTT = refTrackEta[ii]; + int ii = rand.Integer(refTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 0.5, centralityM, weight); + spectra.fill(HIST("hNumberOfReferenceTriggers"), static_cast(refTrackPhi.size()), weight); + phiTT = refTrackPhi[ii]; + etaTT = refTrackEta[ii]; - } else if (analyzeSignal == 1 && sigTrackPhi.size() > 0) { + } else if (analyzeSignal == 1 && sigTrackPhi.size() > 0) { - int ii = rand->Integer(sigTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 1.5, centralityM, weight); - spectra.fill(HIST("hPocetSignalTriggeru"), static_cast(sigTrackPhi.size()), weight); - phiTT = sigTrackPhi[ii]; - etaTT = sigTrackEta[ii]; - } + int ii = rand.Integer(sigTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 1.5, centralityM, weight); + spectra.fill(HIST("hNumberOfSignalTriggers"), static_cast(sigTrackPhi.size()), weight); + phiTT = sigTrackPhi[ii]; + etaTT = sigTrackEta[ii]; + } - spectra.fill(HIST("hPocetTracku"), i, weight); + spectra.fill(HIST("hNumberOfTracks"), i, weight); for (const auto& jet : jets) { // jet spectra before TT selection @@ -464,8 +464,8 @@ struct TrackJetSpectra { break; } - randJetPhi = rand->Uniform(-constants::math::PI, constants::math::PI); - randJetEta = rand->Uniform(-0.5, 0.5); + randJetPhi = rand.Uniform(-constants::math::PI, constants::math::PI); + randJetEta = rand.Uniform(-0.5, 0.5); float vphi1 = TVector2::Phi_mpi_pi(randJetPhi - jet1Phi); float vphi2 = TVector2::Phi_mpi_pi(randJetPhi - jet2Phi); @@ -473,9 +473,9 @@ struct TrackJetSpectra { float veta1 = randJetEta - jet1Eta; float veta2 = randJetEta - jet2Eta; float vetaTT = randJetEta - etaTT; - float dist1 = std::sqrt(vphi1 * vphi1 + veta1 * veta1); - float dist2 = std::sqrt(vphi2 * vphi2 + veta2 * veta2); - float distTT = std::sqrt(vphiTT * vphiTT + vetaTT * vetaTT); + float dist1 = std::hypot(vphi1, veta1); + float dist2 = std::hypot(vphi2, veta2); + float distTT = std::hypot(vphiTT, vetaTT); if (dist1 > randomConeDistanceFactor * jetR && dist2 > randomConeDistanceFactor * jetR && @@ -554,7 +554,7 @@ struct TrackJetSpectra { bool bIsThereTTSig = sigTrackPhi.size() > 0; if (bIsThereTTSig) - phiTT = sigTrackPhi[rand->Integer(sigTrackPhi.size())]; + phiTT = sigTrackPhi[rand.Integer(sigTrackPhi.size())]; for (const auto& jetBase : jetsBase) { bool bIsBaseJetRecoil = false; /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -808,7 +808,7 @@ struct TrackJetSpectra { std::vector vPhiOfTT; - float rnd = rand->Rndm(); + float rnd = rand.Rndm(); bool analyzeSignal = 0; float rho = collision.rho(); @@ -839,7 +839,7 @@ struct TrackJetSpectra { int ii = -1; // index of selected particle level trigger track if (vPhiOfTT.size() > 0) { - ii = rand->Integer(vPhiOfTT.size()); + ii = rand.Integer(vPhiOfTT.size()); if (analyzeSignal == 0) { spectra.fill(HIST("hTTCountPartLevel"), 0.5, weight); } else { From 5a63c44a322a6b181ebb4515fb62cc75cc78789e Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 26 May 2026 19:04:52 +0000 Subject: [PATCH 5/5] Please consider the following formatting changes --- PWGJE/Tasks/trackJetSpectra.cxx | 294 ++++++++++++++++---------------- 1 file changed, 147 insertions(+), 147 deletions(-) diff --git a/PWGJE/Tasks/trackJetSpectra.cxx b/PWGJE/Tasks/trackJetSpectra.cxx index 7bc5f08dc09..06119362481 100644 --- a/PWGJE/Tasks/trackJetSpectra.cxx +++ b/PWGJE/Tasks/trackJetSpectra.cxx @@ -23,20 +23,20 @@ #include #include -#include -#include -#include #include +#include #include +#include #include #include #include +#include #include -#include #include #include #include +#include #include #include @@ -185,186 +185,186 @@ struct TrackJetSpectra { // Disitribution of tracks if (doprocessJetsMCDet || doprocessJetsMCDetWeighted || doprocessJets) { - spectra.add("hNumberOfTracks", "Number", kTH1F, {{1000, 0., 1000., "Number of Events"}}); - spectra.add("hNumberOfSignalTriggers", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); - spectra.add("hNumberOfReferenceTriggers", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); - spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); - spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); - spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); - spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); - spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH2F, {pT, centrality}); - spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); - spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); + spectra.add("hNumberOfTracks", "Number", kTH1F, {{1000, 0., 1000., "Number of Events"}}); + spectra.add("hNumberOfSignalTriggers", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); + spectra.add("hNumberOfReferenceTriggers", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); + spectra.add("hRecoilJetRefPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hRecoilJetSigPt", "#it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hRecoilJetRefCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hRecoilJetSigCorrPt", "Corrected #it{p}_{T} distribution of recoil jets", kTH2F, {{200, 0., 200., "Number of Events"}, centrality}); + spectra.add("hTrackPt", "#it{p}_{T} distribution of tracks", kTH2F, {pT, centrality}); + spectra.add("hTrackPhi", "#varphi distribution of tracks", kTH1F, {phiAngle}); + spectra.add("hTrackEta", "#eta distribution of tracks", kTH1F, {etaTracks}); - spectra.add("hTrackPtPhi", "#it{p}_{T} vs. #varphi distribution of tracks", kTH2F, {pT, phiAngle}); - spectra.add("hTrackPtEta", "#it{p}_{T} vs. #eta distribution of tracks", kTH2F, {pT, etaTracks}); + spectra.add("hTrackPtPhi", "#it{p}_{T} vs. #varphi distribution of tracks", kTH2F, {pT, phiAngle}); + spectra.add("hTrackPtEta", "#it{p}_{T} vs. #eta distribution of tracks", kTH2F, {pT, etaTracks}); - spectra.add("hTrackPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of tracks", kTH3F, {pT, phiAngle, etaTracks}); + spectra.add("hTrackPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of tracks", kTH3F, {pT, phiAngle, etaTracks}); - // Distribution of jets - spectra.add("hJetPt", "#it{p}_{T} distribution of jets", kTH1F, {pT}); - spectra.add("hJetPhi", "#varphi distribution of jets", kTH1F, {phiAngle}); - spectra.add("hJetEta", "#eta distribution of jets", kTH1F, {etaJets}); + // Distribution of jets + spectra.add("hJetPt", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + spectra.add("hJetPhi", "#varphi distribution of jets", kTH1F, {phiAngle}); + spectra.add("hJetEta", "#eta distribution of jets", kTH1F, {etaJets}); - spectra.add("hJetPtPhi", "#it{p}_{T} vs. #varphi distribution of jets", kTH2F, {pT, phiAngle}); - spectra.add("hJetPtEta", "#it{p}_{T} vs. #eta distribution of jets", kTH2F, {pT, etaJets}); + spectra.add("hJetPtPhi", "#it{p}_{T} vs. #varphi distribution of jets", kTH2F, {pT, phiAngle}); + spectra.add("hJetPtEta", "#it{p}_{T} vs. #eta distribution of jets", kTH2F, {pT, etaJets}); - spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); + spectra.add("hJetPtPhiEta", "#it{p}_{T} vs. #varphi vs. #eta distribution of jets", kTH3F, {pT, phiAngle, etaJets}); - spectra.add("hMultFT0A", "Mult. signal from FTOA", kTH2F, {{2000, 0.0, 40000., "FT0A"}, centrality}); - spectra.add("hMultFT0C", "Mult. signal from FTOC", kTH2F, {{2000, 0.0, 40000., "FT0C"}, centrality}); + spectra.add("hMultFT0A", "Mult. signal from FTOA", kTH2F, {{2000, 0.0, 40000., "FT0A"}, centrality}); + spectra.add("hMultFT0C", "Mult. signal from FTOC", kTH2F, {{2000, 0.0, 40000., "FT0C"}, centrality}); - spectra.add("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); + spectra.add("hJetPtCorr", "#it{p}_{T} distribution of jets", kTH1F, {pT}); - spectra.add("hRho", "distribution of rho", kTH1F, {rho}); - spectra.add("hjetArea", "distribution of jet area", kTH1F, {jetArea}); + spectra.add("hRho", "distribution of rho", kTH1F, {rho}); + spectra.add("hjetArea", "distribution of jet area", kTH1F, {jetArea}); - spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); - spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); - spectra.add("hRhovsCentrality", "Rho vs number of tracks", kTH2F, {centrality, rho}); + spectra.add("JetAreavsPt", "#it{p}_{T} vs. jet area distribution of jets", kTH2F, {pT, jetArea}); + spectra.add("hRhovsNTracks", "Rho vs number of tracks", kTH2F, {{2000, 0.0, 40000., "NTracks"}, rho}); + spectra.add("hRhovsCentrality", "Rho vs number of tracks", kTH2F, {centrality, rho}); - spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); - spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); + spectra.add("hSigCorrConePt", "distribution of Signal Corrected perpendicular Cone Pt", kTH1F, {pT}); + spectra.add("hRefCorrConePt", "distribution of Reference Corrected perpendicular Cone Pt", kTH1F, {pT}); - spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH2F, {pT, centrality}); - spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH2F, {pT, centrality}); + spectra.add("hSigRandCorrConePt", "distribution of Signal Corrected random Cone Pt", kTH2F, {pT, centrality}); + spectra.add("hRefRandCorrConePt", "distribution of Reference Corrected random Cone Pt", kTH2F, {pT, centrality}); - spectra.add("hTTCountData", "Number", kTH2F, {{2, 0., 2., "Number TT Data"}, centrality}); - } + spectra.add("hTTCountData", "Number", kTH2F, {{2, 0., 2., "Number TT Data"}, centrality}); + } - if (doprocessJetsMatched) { - spectra.add("hDetLevelInclusiveJetsPt", "All reconstructed inclusive jets", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hFakeInclusiveJetsPt", "Det. level inclusive jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + if (doprocessJetsMatched) { + spectra.add("hDetLevelInclusiveJetsPt", "All reconstructed inclusive jets", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hFakeInclusiveJetsPt", "Det. level inclusive jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hMissedJets_pT", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); + spectra.add("hMissedJets_pT_RecoilJets", "Part. level jets w/o matched pair", kTH1F, {{200, 0.0, 200.}}, setSumw2); - spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); - spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); + spectra.add("hJetPt_resolution", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); - spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); - spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); - spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); - } + spectra.add("hJetPt_DetLevel_vs_PartLevel_RecoilJets", "Correlation recoil jet pT at part. vs. det. levels", kTH2F, {{200, 0.0, 200.}, {200, 0.0, 200.}}, setSumw2); + spectra.add("hJetPt_resolution_RecoilJets", "Jet p_{T} relative resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{100, -5., 5.}, pT}, setSumw2); + spectra.add("hJetPhi_resolution_RecoilJets", "#varphi resolution as a func. of jet #it{p}_{T, part}", kTH2F, {{40, -1., 1.}, pT}, setSumw2); + } - if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { - spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + if (doprocessMCPartLevel || doprocessMCPartLevelWeighted) { + spectra.add("hRecoilJetRefPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetSigPtMCP", "#it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetRefCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hRecoilJetSigCorrPtMCP", "Corrected #it{p}_{T} distribution of recoil jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hEventSelectionCountPartLevel", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); - spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); + spectra.add("hEventSelectionCountPartLevel", "Number", kTH1F, {{10, 0., 10., "Number of Events"}}); + spectra.add("hMCPTrackPt", "#it{p}_{T} distribution of tracks", kTH1F, {pT}); - spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); - spectra.add("hJetPtMCP", "#it{p}_{T} distribution of jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); + spectra.add("hJetPtEtaPhiRhoArea_Part", "Charact. of inclusive part. level jets", kTHnSparseF, {pT, etaJets, phiAngle, rho, jetArea}); + spectra.add("hJetPtMCP", "#it{p}_{T} distribution of jets", kTH1F, {{200, 0., 200., "p_{T,ch jet} (GeV/c)"}}); - spectra.add("hTTCountPartLevel", "Number", kTH1F, {{2, 0., 2., "Number TT MCP"}}); - } + spectra.add("hTTCountPartLevel", "Number", kTH1F, {{2, 0., 2., "Number TT MCP"}}); + } - if (doprocessTrackEfficiency || doprocessTrackEfficiencyMB) { - spectra.add("hTrackingEfficiencyDenominatorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); - spectra.add("hNonprimaryParticlesPt", "#it{p}_{T} distribution", kTH1F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}}); - spectra.add("hTrackingEfficiencyNumeratorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + if (doprocessTrackEfficiency || doprocessTrackEfficiencyMB) { + spectra.add("hTrackingEfficiencyDenominatorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + spectra.add("hNonprimaryParticlesPt", "#it{p}_{T} distribution", kTH1F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}}); + spectra.add("hTrackingEfficiencyNumeratorPt", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); - spectra.add("hTrackingPhiSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, dphiAngle}); - spectra.add("hTrackingEtaSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, detaTracks}); - spectra.add("hTrackingPtResolutionPt", "#it{p}_{T} distribution", kTH2F, {pTTrack, pTRes}); + spectra.add("hTrackingPhiSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, dphiAngle}); + spectra.add("hTrackingEtaSmearingPt", "#it{p}_{T} distribution", kTH2F, {pT, detaTracks}); + spectra.add("hTrackingPtResolutionPt", "#it{p}_{T} distribution", kTH2F, {pTTrack, pTRes}); - spectra.add("hNTracksPerCollision", "Number", kTH1F, {{1000, 0., 1000., "Number of Events"}}); + spectra.add("hNTracksPerCollision", "Number", kTH1F, {{1000, 0., 1000., "Number of Events"}}); - spectra.add("CentralityC", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); - spectra.add("CentralityM", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); - spectra.add("AllTracksPtCent", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); - } - } + spectra.add("CentralityC", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); + spectra.add("CentralityM", "#it{p}_{T} distribution", kTH1F, {{100, 0., 100., "p_{T,ch} (GeV/c)"}}); + spectra.add("AllTracksPtCent", "#it{p}_{T} distribution", kTH2F, {{200, 0., 200., "p_{T,ch} (GeV/c)"}, centrality}); + } + } - //------------------------------------------------------------------------------ + //------------------------------------------------------------------------------ - template - void fillHistograms(Collision const& collision, Jets const& jets, - Tracks const& tracks, float weight = 1.) + template + void fillHistograms(Collision const& collision, Jets const& jets, + Tracks const& tracks, float weight = 1.) - { + { - const float randomConeDistanceFactor = 2.; - const int maxRandomConeIterations = 1000; + const float randomConeDistanceFactor = 2.; + const int maxRandomConeIterations = 1000; - std::vector sigTrackPhi; - std::vector sigTrackEta; - std::vector refTrackPhi; - std::vector refTrackEta; + std::vector sigTrackPhi; + std::vector sigTrackEta; + std::vector refTrackPhi; + std::vector refTrackEta; - float multFT0A = collision.multFT0A(); - float multFT0C = collision.multFT0C(); - float centralityM = collision.centFT0M(); + float multFT0A = collision.multFT0A(); + float multFT0C = collision.multFT0C(); + float centralityM = collision.centFT0M(); - spectra.fill(HIST("hMultFT0A"), multFT0A, centralityM, weight); - spectra.fill(HIST("hMultFT0C"), multFT0C, centralityM, weight); + spectra.fill(HIST("hMultFT0A"), multFT0A, centralityM, weight); + spectra.fill(HIST("hMultFT0C"), multFT0C, centralityM, weight); - float jetR2 = jetR * jetR; - float rho = collision.rho(); + float jetR2 = jetR * jetR; + float rho = collision.rho(); - spectra.fill(HIST("hRho"), rho, weight); + spectra.fill(HIST("hRho"), rho, weight); - int i = 0; - for (const auto& track : tracks) { - // check whether track passes the selection flags - if (skipTrack(track)) - continue; - i++; - auto trackPt = track.pt(); - auto trackPhi = track.phi(); - auto trackEta = track.eta(); + int i = 0; + for (const auto& track : tracks) { + // check whether track passes the selection flags + if (skipTrack(track)) + continue; + i++; + auto trackPt = track.pt(); + auto trackPhi = track.phi(); + auto trackEta = track.eta(); - spectra.fill(HIST("hTrackPt"), trackPt, centralityM, weight); - spectra.fill(HIST("hTrackPhi"), trackPhi, weight); - spectra.fill(HIST("hTrackEta"), trackEta, weight); + spectra.fill(HIST("hTrackPt"), trackPt, centralityM, weight); + spectra.fill(HIST("hTrackPhi"), trackPhi, weight); + spectra.fill(HIST("hTrackEta"), trackEta, weight); - spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi, weight); - spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta, weight); + spectra.fill(HIST("hTrackPtPhi"), trackPt, trackPhi, weight); + spectra.fill(HIST("hTrackPtEta"), trackPt, trackEta, weight); - spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta, weight); + spectra.fill(HIST("hTrackPtPhiEta"), trackPt, trackPhi, trackEta, weight); - if ((signalTriggerMin <= trackPt) && (trackPt <= signalTriggerMax)) { - sigTrackPhi.push_back(trackPhi); - sigTrackEta.push_back(trackEta); - } + if ((signalTriggerMin <= trackPt) && (trackPt <= signalTriggerMax)) { + sigTrackPhi.push_back(trackPhi); + sigTrackEta.push_back(trackEta); + } - if ((referenceTriggerMin <= trackPt) && (trackPt <= referenceTriggerMax)) { - refTrackPhi.push_back(trackPhi); - refTrackEta.push_back(trackEta); - } - } - spectra.fill(HIST("hRhovsNTracks"), i, rho, weight); - spectra.fill(HIST("hRhovsCentrality"), centralityM, rho, weight); + if ((referenceTriggerMin <= trackPt) && (trackPt <= referenceTriggerMax)) { + refTrackPhi.push_back(trackPhi); + refTrackEta.push_back(trackEta); + } + } + spectra.fill(HIST("hRhovsNTracks"), i, rho, weight); + spectra.fill(HIST("hRhovsCentrality"), centralityM, rho, weight); - float perpConePhi = -99; - float phiTT = -999; // this will trigger track phi - float etaTT = -999; // trigger track eta - float rnd = rand.Rndm(); - bool analyzeSignal = 0; // 0= reference TT and 1= signal TT + float perpConePhi = -99; + float phiTT = -999; // this will trigger track phi + float etaTT = -999; // trigger track eta + float rnd = rand.Rndm(); + bool analyzeSignal = 0; // 0= reference TT and 1= signal TT - if (rnd < sigToRefFraction) { - analyzeSignal = 1; - } + if (rnd < sigToRefFraction) { + analyzeSignal = 1; + } - if (analyzeSignal == 0 && refTrackPhi.size() > 0) { + if (analyzeSignal == 0 && refTrackPhi.size() > 0) { - int ii = rand.Integer(refTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 0.5, centralityM, weight); - spectra.fill(HIST("hNumberOfReferenceTriggers"), static_cast(refTrackPhi.size()), weight); - phiTT = refTrackPhi[ii]; - etaTT = refTrackEta[ii]; + int ii = rand.Integer(refTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 0.5, centralityM, weight); + spectra.fill(HIST("hNumberOfReferenceTriggers"), static_cast(refTrackPhi.size()), weight); + phiTT = refTrackPhi[ii]; + etaTT = refTrackEta[ii]; - } else if (analyzeSignal == 1 && sigTrackPhi.size() > 0) { + } else if (analyzeSignal == 1 && sigTrackPhi.size() > 0) { - int ii = rand.Integer(sigTrackPhi.size()); - spectra.fill(HIST("hTTCountData"), 1.5, centralityM, weight); - spectra.fill(HIST("hNumberOfSignalTriggers"), static_cast(sigTrackPhi.size()), weight); - phiTT = sigTrackPhi[ii]; - etaTT = sigTrackEta[ii]; - } + int ii = rand.Integer(sigTrackPhi.size()); + spectra.fill(HIST("hTTCountData"), 1.5, centralityM, weight); + spectra.fill(HIST("hNumberOfSignalTriggers"), static_cast(sigTrackPhi.size()), weight); + phiTT = sigTrackPhi[ii]; + etaTT = sigTrackEta[ii]; + } spectra.fill(HIST("hNumberOfTracks"), i, weight); @@ -974,14 +974,14 @@ struct TrackJetSpectra { } for (const auto& jetDet : detJets) { - if(isJetWithHighPtConstituent(jetDet, tracks)) - continue; - - auto detJetPt = jetDet.pt(); - spectra.fill(HIST("hDetLevelInclusiveJetsPt"), detJetPt, weight); - if (!jetDet.has_matchedJetGeo()) { - spectra.fill(HIST("hFakeInclusiveJetsPt"), detJetPt, weight); - } + if (isJetWithHighPtConstituent(jetDet, tracks)) + continue; + + auto detJetPt = jetDet.pt(); + spectra.fill(HIST("hDetLevelInclusiveJetsPt"), detJetPt, weight); + if (!jetDet.has_matchedJetGeo()) { + spectra.fill(HIST("hFakeInclusiveJetsPt"), detJetPt, weight); + } } } };