From 66517d93df61ba6432289ee0a3f73db5e9243084 Mon Sep 17 00:00:00 2001 From: Alberto Caliva Date: Wed, 22 Nov 2023 12:50:58 +0100 Subject: [PATCH 1/3] Add task for measurement of nuclei in jets and ue --- PWGLF/Tasks/CMakeLists.txt | 5 + PWGLF/Tasks/nuclei_in_jets.cxx | 526 +++++++++++++++++++++++++++++++++ 2 files changed, 531 insertions(+) create mode 100644 PWGLF/Tasks/nuclei_in_jets.cxx diff --git a/PWGLF/Tasks/CMakeLists.txt b/PWGLF/Tasks/CMakeLists.txt index fbb205c3889..7fcae9513c6 100644 --- a/PWGLF/Tasks/CMakeLists.txt +++ b/PWGLF/Tasks/CMakeLists.txt @@ -215,3 +215,8 @@ o2physics_add_dpl_workflow(rsn-analysis-thnsparse SOURCES rsnanalysisTHnSparse.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(nuclei-in-jets + SOURCES nuclei_in_jets.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) diff --git a/PWGLF/Tasks/nuclei_in_jets.cxx b/PWGLF/Tasks/nuclei_in_jets.cxx new file mode 100644 index 00000000000..993f843c76c --- /dev/null +++ b/PWGLF/Tasks/nuclei_in_jets.cxx @@ -0,0 +1,526 @@ +// 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. +// +// 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 Alberto Caliva (alberto.caliva@cern.ch) +/// \since November 22, 2023 + +#include +#include +#include +#include +#include +#include +#include +#include "Framework/runDataProcessing.h" +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "ReconstructionDataFormats/Track.h" +#include "Common/Core/trackUtilities.h" +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/PIDResponse.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::constants::physics; +using namespace std; + +using SelectedCollisions = soa::Join; + +using FullTracks = soa::Join; + +using MCTracks = soa::Join; + +struct nuclei_in_jets { + + // QC Histograms + HistogramRegistry registryQC{ + "registryQC", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; + + // Analysis Histograms: Data + HistogramRegistry registryData{ + "registryData", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; + + // Analysis Histograms: MC + HistogramRegistry registryMC{ + "registryMC", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; + + // Global Parameters + Configurable min_pt_leading{"min_pt_leading", 5.0f, "minimum pt of leading particle"}; + Configurable max_jet_radius{"max_jet_radius", 0.1f, "maximum jet resolution parameter R"}; + Configurable particle_of_interest{"particle_of_interest", 0, "0=antiproton, 1=antideuteron, 2=antihelium3"}; + + // Track Parameters + Configurable min_ITS_nClusters{"min_ITS_nClusters", 4, "minimum number of found ITS clusters"}; + Configurable min_TPC_nClusters{"min_TPC_nClusters", 80, "minimum number of found TPC clusters"}; + Configurable min_TPC_nCrossedRows{"min_TPC_nCrossedRows", 80, "minimum number of TPC crossed pad rows"}; + Configurable max_chi2_TPC{"max_chi2_TPC", 4.0f, "maximum TPC chi^2/Ncls"}; + Configurable max_chi2_ITS{"max_chi2_ITS", 36.0f, "maximum ITS chi^2/Ncls"}; + Configurable min_pt{"min_pt", 0.2f, "minimum pt of the tracks"}; + Configurable min_eta{"min_eta", -0.8f, "minimum_eta"}; + Configurable max_eta{"max_eta", +0.8f, "maximum_eta"}; + Configurable max_dcaxy{"max_dcaxy", 0.1f, "Maximum DCAxy"}; + Configurable max_dcaz{"max_dcaz", 0.1f, "Maximum DCAz"}; + Configurable min_nsigmaTPC{"min_nsigmaTPC", -3.0f, "Minimum nsigma TPC"}; + Configurable max_nsigmaTPC{"max_nsigmaTPC", +3.0f, "Maximum nsigma TPC"}; + Configurable require_primVtx_contributor{"require_primVtx_contributor", true, "require that the track is a PV contributor"}; + + // List of Particles + enum particle { proton, + deuteron, + helium }; + + void init(InitContext const&) + { + // Global Properties and QC + registryQC.add("number_of_events_data", "number of events in data", HistType::kTH1F, {{4, 0, 4, "1 = all events, 2 = selected events, 3 = events with pt>pt_threshold, 4 = events with pt>pt_threshold and particle of interest"}}); + registryQC.add("jet_plus_ue_multiplicity", "jet + underlying-event multiplicity", HistType::kTH1F, {{300, 0, 300, "#it{N}_{ch}"}}); + registryQC.add("jet_multiplicity", "jet multiplicity", HistType::kTH1F, {{300, 0, 300, "#it{N}_{ch}"}}); + registryQC.add("ue_multiplicity", "underlying-event multiplicity", HistType::kTH1F, {{300, 0, 300, "#it{N}_{ch}"}}); + registryQC.add("pt_leading", "pt leading", HistType::kTH1F, {{500, 0, 50, "#it{p}_{T} (GeV/#it{c})"}}); + registryQC.add("eta_phi_jet", "DeltaEta DeltaPhi jet", HistType::kTH2F, {{200, -0.5, 0.5, "#Delta#eta"}, {200, 0.0, TMath::Pi(), "#Delta#phi"}}); + + // Antiprotons + registryData.add("antiproton_jet_tpc", "antiproton_jet_tpc", HistType::kTH3F, {{20, 0.0, 1.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TPC}"}, {10, 0, 100, "#it{N}_{ch}"}}); + registryData.add("antiproton_jet_tof", "antiproton_jet_tof", HistType::kTH3F, {{90, 0.5, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TOF}"}, {10, 0, 100, "#it{N}_{ch}"}}); + registryData.add("antiproton_ue_tpc", "antiproton_ue_tpc", HistType::kTH3F, {{20, 0.0, 1.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TPC}"}, {10, 0, 100, "#it{N}_{ch}"}}); + registryData.add("antiproton_ue_tof", "antiproton_ue_tof", HistType::kTH3F, {{90, 0.5, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TOF}"}, {10, 0, 100, "#it{N}_{ch}"}}); + + // Antideuterons + registryData.add("antideuteron_jet_tpc", "antideuteron_jet_tpc", HistType::kTH3F, {{10, 0.0, 1.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TPC}"}, {10, 0, 100, "#it{N}_{ch}"}}); + registryData.add("antideuteron_jet_tof", "antideuteron_jet_tof", HistType::kTH3F, {{45, 0.5, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TOF}"}, {10, 0, 100, "#it{N}_{ch}"}}); + registryData.add("antideuteron_ue_tpc", "antideuteron_ue_tpc", HistType::kTH3F, {{10, 0.0, 1.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TPC}"}, {10, 0, 100, "#it{N}_{ch}"}}); + registryData.add("antideuteron_ue_tof", "antideuteron_ue_tof", HistType::kTH3F, {{45, 0.5, 5.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TOF}"}, {10, 0, 100, "#it{N}_{ch}"}}); + + // Antihelium-3 + registryData.add("antihelium3_jet_tpc", "antihelium3_jet_tpc", HistType::kTH3F, {{40, 1.0, 7.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TPC}"}, {10, 0, 100, "#it{N}_{ch}"}}); + registryData.add("antihelium3_ue_tpc", "antihelium3_ue_tpc", HistType::kTH3F, {{40, 1.0, 7.0, "#it{p}_{T} (GeV/#it{c})"}, {200, -10.0, 10.0, "n#sigma_{TPC}"}, {10, 0, 100, "#it{N}_{ch}"}}); + } + + // Single-Track Selection for the Particle of Interest + template + bool passedTrackSelection(const T1& track) + { + if (!track.hasITS()) + return false; + if (track.itsNCls() < min_ITS_nClusters) + return false; + if (!track.hasTPC()) + return false; + if (track.tpcNClsFound() < min_TPC_nClusters) + return false; + if (track.tpcNClsCrossedRows() < min_TPC_nCrossedRows) + return false; + if (track.tpcChi2NCl() > max_chi2_TPC) + return false; + if (track.itsChi2NCl() > max_chi2_ITS) + return false; + if (track.eta() < min_eta || track.eta() > max_eta) + return false; + if (track.pt() < min_pt) + return false; + if (TMath::Abs(track.dcaXY()) > max_dcaxy) + return false; + if (TMath::Abs(track.dcaZ()) > max_dcaz) + return false; + + return true; + } + + // Single-Track Selection for Particles inside Jets + template + bool passedMinimalTrackSelection(const T2& track) + { + if (!track.hasITS()) + return false; + if (track.itsNCls() < 2) + return false; + if (!track.hasTPC()) + return false; + if (track.tpcNClsFound() < 70) + return false; + if (track.tpcNClsCrossedRows() < 70) + return false; + if (track.tpcChi2NCl() > 4) + return false; + if (track.itsChi2NCl() > 36) + return false; + if (track.eta() < -0.8 || track.eta() > 0.8) + return false; + if (track.pt() < 0.15) + return false; + if (TMath::Abs(track.dcaXY()) > 0.2) + return false; + if (TMath::Abs(track.dcaZ()) > 0.2) + return false; + + return true; + } + + template + bool isParticleOfInterest(const T3& track) + { + // Variables + float nsigmaTPCPr = track.tpcNSigmaPr(); + float nsigmaTOFPr = track.tofNSigmaPr(); + float nsigmaTPCDe = track.tpcNSigmaDe(); + float nsigmaTOFDe = track.tofNSigmaDe(); + float nsigmaTPCHe = track.tpcNSigmaHe(); + float pt = track.pt(); + + // Antimatter Only + if (track.sign() > 0) + return false; + + // Proton ID + if (particle_of_interest == particle::proton) { + if (pt < 1.0 && TMath::Abs(nsigmaTPCPr) < 8.0) + return true; + if (pt >= 1.0 && nsigmaTPCPr > min_nsigmaTPC && nsigmaTPCPr < max_nsigmaTPC && track.hasTOF() && TMath::Abs(nsigmaTOFPr) < 10.0) + return true; + return false; + } + + // Deuteron ID + if (particle_of_interest == particle::deuteron) { + if (pt < 1.0 && TMath::Abs(nsigmaTPCDe) < 8.0) + return true; + if (pt >= 1.0 && nsigmaTPCDe > min_nsigmaTPC && nsigmaTPCDe < max_nsigmaTPC && track.hasTOF() && TMath::Abs(nsigmaTOFDe) < 10.0) + return true; + return false; + } + + // Helium-3 ID + if (particle_of_interest == particle::helium) { + if ((0.5 * pt) >= 1.0 && TMath::Abs(nsigmaTPCHe) < 8.0) + return true; + return false; + } + + return false; + } + + // Minimum + float Minimum(float x1, float x2) + { + float x_min(x1); + if (x1 < x2) + x_min = x1; + if (x1 >= x2) + x_min = x2; + + return x_min; + } + + // Process Data + void processData(SelectedCollisions::iterator const& collision, FullTracks const& tracks) + { + // Event Counter (before event selection) + registryQC.fill(HIST("number_of_events_data"), 0.5); + + // Event Selection + if (!collision.sel8()) + return; + + // Event Counter (after event selection) + registryQC.fill(HIST("number_of_events_data"), 1.5); + + // Reduced Event + vector particle_ID; + int leading_ID; + bool containsParticleOfInterest(false); + float pt_max(0); + + // Loop over Reconstructed Tracks + for (auto track : tracks) { + + // Track Selection for Jet + if (!passedMinimalTrackSelection(track)) + continue; + if (!track.passedITSRefit()) + continue; + if (!track.passedTPCRefit()) + continue; + + // Track Index + int i = track.globalIndex(); + + // Trigger: Particle of Interest + if (isParticleOfInterest(track)) + containsParticleOfInterest = true; + + // Find pt Leading + if (track.pt() > pt_max) { + leading_ID = i; + pt_max = track.pt(); + } + + // Store Array Element + particle_ID.push_back(i); + } + + // Histogram with pt_leading + registryQC.fill(HIST("pt_leading"), pt_max); + + // Selection of Events with pt > pt_leading + if ((int)particle_ID.size() < 2) + return; + if (pt_max < min_pt_leading) + return; + + // Event Counter (after pt > pt_max selection) + registryQC.fill(HIST("number_of_events_data"), 2.5); + + // Skip Events with no Particle of Interest + if (!containsParticleOfInterest) + return; + + // Event Counter (events with pt > pt_max that contain particle of interest) + registryQC.fill(HIST("number_of_events_data"), 3.5); + + // Momentum of the Leading Particle + auto leading_track = tracks.iteratorAt(leading_ID); + TVector3 p_leading(leading_track.px(), leading_track.py(), leading_track.pz()); + + // Array of Particles inside Jet + vector jet_particle_ID; + jet_particle_ID.push_back(leading_ID); + + // Labels + Int_t exit(0); + Int_t nPartAssociated(0); + + // Jet Finder + do { + // Initialization + float distance_jet_min(1e+08); + float distance_bkg_min(1e+08); + int label_jet_particle(0); + int i_jet_particle(0); + + for (int i = 0; i < (int)particle_ID.size(); i++) { + + // Skip Leading Particle & Elements already associated to the Jet + if (particle_ID[i] == leading_ID || particle_ID[i] == -1) + continue; + + // Get Particle Momentum + auto stored_track = tracks.iteratorAt(particle_ID[i]); + TVector3 p_particle(stored_track.px(), stored_track.py(), stored_track.pz()); + + // Variables + float one_over_pt2_part = 1.0 / (p_particle.Pt() * p_particle.Pt()); + float one_over_pt2_lead = 1.0 / (p_leading.Pt() * p_leading.Pt()); + float deltaEta = p_particle.Eta() - p_leading.Eta(); + float deltaPhi = TVector2::Phi_0_2pi(p_particle.Phi() - p_leading.Phi()); + float min = Minimum(one_over_pt2_part, one_over_pt2_lead); + float Delta2 = deltaEta * deltaEta + deltaPhi * deltaPhi; + + // Distances + float distance_jet = min * Delta2 / (max_jet_radius * max_jet_radius); + float distance_bkg = one_over_pt2_part; + + // Find Minimum Distance Jet + if (distance_jet < distance_jet_min) { + distance_jet_min = distance_jet; + label_jet_particle = particle_ID[i]; + i_jet_particle = i; + } + + // Find Minimum Distance Bkg + if (distance_bkg < distance_bkg_min) { + distance_bkg_min = distance_bkg; + } + } + + if (distance_jet_min <= distance_bkg_min) { + + // Add Particle to Jet + jet_particle_ID.push_back(label_jet_particle); + + // Update Momentum of Leading Particle + auto jet_track = tracks.iteratorAt(label_jet_particle); + TVector3 p_i(jet_track.px(), jet_track.py(), jet_track.pz()); + p_leading = p_leading + p_i; + + // Remove Element + particle_ID[i_jet_particle] = -1; + nPartAssociated++; + } + + if (nPartAssociated >= ((int)particle_ID.size() - 1)) + exit = 1; + if (distance_jet_min > distance_bkg_min) + exit = 2; + + } while (exit == 0); + + // Fill Jet Multiplicity + registryQC.fill(HIST("jet_plus_ue_multiplicity"), jet_particle_ID.size()); + + // Perpendicular Cones for UE Estimate + TVector3 z_positive(0, 0, 1); + TVector3 z_negative(0, 0, -1); + TVector3 v1 = (z_positive.Cross(p_leading)).Unit(); + TVector3 v2 = (z_negative.Cross(p_leading)).Unit(); + TVector3 v3 = (p_leading.Cross(v1)).Unit(); + TVector3 v4 = (p_leading.Cross(v2)).Unit(); + + // Store UE + vector ue_particle_ID; + + for (int i = 0; i < (int)particle_ID.size(); i++) { + + // Skip Leading Particle & Elements already associated to the Jet + if (particle_ID[i] == leading_ID || particle_ID[i] == -1) + continue; + + // Get UE Track + auto ue_track = tracks.iteratorAt(particle_ID[i]); + + // Variables + float deltaEta1 = ue_track.eta() - v1.Eta(); + float deltaEta2 = ue_track.eta() - v2.Eta(); + float deltaEta3 = ue_track.eta() - v3.Eta(); + float deltaEta4 = ue_track.eta() - v4.Eta(); + + float deltaPhi1 = TVector2::Phi_0_2pi(ue_track.phi() - v1.Phi()); + float deltaPhi2 = TVector2::Phi_0_2pi(ue_track.phi() - v2.Phi()); + float deltaPhi3 = TVector2::Phi_0_2pi(ue_track.phi() - v3.Phi()); + float deltaPhi4 = TVector2::Phi_0_2pi(ue_track.phi() - v4.Phi()); + + float dr1 = TMath::Sqrt(deltaEta1 * deltaEta1 + deltaPhi1 * deltaPhi1); + float dr2 = TMath::Sqrt(deltaEta2 * deltaEta2 + deltaPhi2 * deltaPhi2); + float dr3 = TMath::Sqrt(deltaEta3 * deltaEta3 + deltaPhi3 * deltaPhi3); + float dr4 = TMath::Sqrt(deltaEta4 * deltaEta4 + deltaPhi4 * deltaPhi4); + + // Store Particles in the UE + if (dr1 < max_jet_radius || dr2 < max_jet_radius || dr3 < max_jet_radius || dr4 < max_jet_radius) { + ue_particle_ID.push_back(particle_ID[i]); + } + } + registryQC.fill(HIST("ue_multiplicity"), (int)ue_particle_ID.size() / 4); + + // Jet Multiplicity + int jet_Nch = (int)jet_particle_ID.size() - (int)ue_particle_ID.size() / 4; + registryQC.fill(HIST("jet_multiplicity"), jet_Nch); + + // Loop over particles inside Jet + for (int i = 0; i < (int)jet_particle_ID.size(); i++) { + + auto jet_track = tracks.iteratorAt(jet_particle_ID[i]); + TVector3 p_i(jet_track.px(), jet_track.py(), jet_track.pz()); + + float deltaEta = p_i.Eta() - p_leading.Eta(); + float deltaPhi = TVector2::Phi_0_2pi(p_i.Phi() - p_leading.Phi()); + registryQC.fill(HIST("eta_phi_jet"), deltaEta, deltaPhi); + + // Track Selection + if (!passedTrackSelection(jet_track)) + continue; + if (require_primVtx_contributor && !(jet_track.isPVContributor())) + continue; + + // Variables + float nsigmaTPCPr = jet_track.tpcNSigmaPr(); + float nsigmaTOFPr = jet_track.tofNSigmaPr(); + float nsigmaTPCDe = jet_track.tpcNSigmaDe(); + float nsigmaTOFDe = jet_track.tofNSigmaDe(); + float nsigmaTPCHe = jet_track.tpcNSigmaHe(); + float pt = jet_track.pt(); + + // Antiproton + if (particle_of_interest == particle::proton) { + if (pt < 1.0) + registryData.fill(HIST("antiproton_jet_tpc"), pt, nsigmaTPCPr, jet_Nch); + if (pt >= 1.0 && nsigmaTPCPr > min_nsigmaTPC && nsigmaTPCPr < max_nsigmaTPC && jet_track.hasTOF()) + registryData.fill(HIST("antiproton_jet_tof"), pt, nsigmaTOFPr, jet_Nch); + } + + // Antideuteron + if (particle_of_interest == particle::deuteron) { + if (pt < 1.0) + registryData.fill(HIST("antideuteron_jet_tpc"), pt, nsigmaTPCDe, jet_Nch); + if (pt >= 1.0 && nsigmaTPCDe > min_nsigmaTPC && nsigmaTPCDe < max_nsigmaTPC && jet_track.hasTOF()) + registryData.fill(HIST("antideuteron_jet_tof"), pt, nsigmaTOFDe, jet_Nch); + } + + // Antihelium3 + if (particle_of_interest == particle::helium) { + registryData.fill(HIST("antihelium3_jet_tpc"), 2.0 * pt, nsigmaTPCHe, jet_Nch); + } + } + + // Loop over particles inside UE + for (int i = 0; i < (int)ue_particle_ID.size(); i++) { + + auto ue_track = tracks.iteratorAt(ue_particle_ID[i]); + + // Track Selection + if (!passedTrackSelection(ue_track)) + continue; + if (require_primVtx_contributor && !(ue_track.isPVContributor())) + continue; + + // Variables + float nsigmaTPCPr = ue_track.tpcNSigmaPr(); + float nsigmaTOFPr = ue_track.tofNSigmaPr(); + float nsigmaTPCDe = ue_track.tpcNSigmaDe(); + float nsigmaTOFDe = ue_track.tofNSigmaDe(); + float nsigmaTPCHe = ue_track.tpcNSigmaHe(); + float pt = ue_track.pt(); + + // Antiproton + if (particle_of_interest == particle::proton) { + if (pt < 1.0) + registryData.fill(HIST("antiproton_ue_tpc"), pt, nsigmaTPCPr, jet_Nch); + if (pt >= 1.0 && nsigmaTPCPr > min_nsigmaTPC && nsigmaTPCPr < max_nsigmaTPC && ue_track.hasTOF()) + registryData.fill(HIST("antiproton_ue_tof"), pt, nsigmaTOFPr, jet_Nch); + } + + // Antideuteron + if (particle_of_interest == particle::deuteron) { + if (pt < 1.0) + registryData.fill(HIST("antideuteron_ue_tpc"), pt, nsigmaTPCDe, jet_Nch); + if (pt >= 1.0 && nsigmaTPCDe > min_nsigmaTPC && nsigmaTPCDe < max_nsigmaTPC && ue_track.hasTOF()) + registryData.fill(HIST("antideuteron_ue_tof"), pt, nsigmaTOFDe, jet_Nch); + } + + // Antihelium3 + if (particle_of_interest == particle::helium) { + registryData.fill(HIST("antihelium3_ue_tpc"), 2.0 * pt, nsigmaTPCHe, jet_Nch); + } + } + + } // end processData + PROCESS_SWITCH(nuclei_in_jets, processData, "Process data", true); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From 3620ef4c5701370fd085bf20900e2f7e4f134115 Mon Sep 17 00:00:00 2001 From: Alberto Caliva Date: Wed, 22 Nov 2023 13:00:06 +0100 Subject: [PATCH 2/3] Use static_cast -> Fixed --- PWGLF/Tasks/nuclei_in_jets.cxx | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/PWGLF/Tasks/nuclei_in_jets.cxx b/PWGLF/Tasks/nuclei_in_jets.cxx index 993f843c76c..0252905fd64 100644 --- a/PWGLF/Tasks/nuclei_in_jets.cxx +++ b/PWGLF/Tasks/nuclei_in_jets.cxx @@ -287,7 +287,7 @@ struct nuclei_in_jets { registryQC.fill(HIST("pt_leading"), pt_max); // Selection of Events with pt > pt_leading - if ((int)particle_ID.size() < 2) + if (static_castparticle_ID.size() < 2) return; if (pt_max < min_pt_leading) return; @@ -322,7 +322,7 @@ struct nuclei_in_jets { int label_jet_particle(0); int i_jet_particle(0); - for (int i = 0; i < (int)particle_ID.size(); i++) { + for (int i = 0; i < static_castparticle_ID.size(); i++) { // Skip Leading Particle & Elements already associated to the Jet if (particle_ID[i] == leading_ID || particle_ID[i] == -1) @@ -372,7 +372,7 @@ struct nuclei_in_jets { nPartAssociated++; } - if (nPartAssociated >= ((int)particle_ID.size() - 1)) + if (nPartAssociated >= (static_castparticle_ID.size() - 1)) exit = 1; if (distance_jet_min > distance_bkg_min) exit = 2; @@ -393,7 +393,7 @@ struct nuclei_in_jets { // Store UE vector ue_particle_ID; - for (int i = 0; i < (int)particle_ID.size(); i++) { + for (int i = 0; i < static_castparticle_ID.size(); i++) { // Skip Leading Particle & Elements already associated to the Jet if (particle_ID[i] == leading_ID || particle_ID[i] == -1) @@ -423,14 +423,14 @@ struct nuclei_in_jets { ue_particle_ID.push_back(particle_ID[i]); } } - registryQC.fill(HIST("ue_multiplicity"), (int)ue_particle_ID.size() / 4); + registryQC.fill(HIST("ue_multiplicity"), static_castue_particle_ID.size() / 4); // Jet Multiplicity - int jet_Nch = (int)jet_particle_ID.size() - (int)ue_particle_ID.size() / 4; + int jet_Nch = static_castjet_particle_ID.size() - static_castue_particle_ID.size() / 4; registryQC.fill(HIST("jet_multiplicity"), jet_Nch); // Loop over particles inside Jet - for (int i = 0; i < (int)jet_particle_ID.size(); i++) { + for (int i = 0; i < static_castjet_particle_ID.size(); i++) { auto jet_track = tracks.iteratorAt(jet_particle_ID[i]); TVector3 p_i(jet_track.px(), jet_track.py(), jet_track.pz()); @@ -476,7 +476,7 @@ struct nuclei_in_jets { } // Loop over particles inside UE - for (int i = 0; i < (int)ue_particle_ID.size(); i++) { + for (int i = 0; i < static_castue_particle_ID.size(); i++) { auto ue_track = tracks.iteratorAt(ue_particle_ID[i]); From a43b74f6c69f1f9c470f423e2b11bad1c8f9c9c1 Mon Sep 17 00:00:00 2001 From: Alberto Caliva Date: Wed, 22 Nov 2023 13:03:39 +0100 Subject: [PATCH 3/3] fixed static cast --- PWGLF/Tasks/nuclei_in_jets.cxx | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/PWGLF/Tasks/nuclei_in_jets.cxx b/PWGLF/Tasks/nuclei_in_jets.cxx index 0252905fd64..622d8402a36 100644 --- a/PWGLF/Tasks/nuclei_in_jets.cxx +++ b/PWGLF/Tasks/nuclei_in_jets.cxx @@ -287,7 +287,7 @@ struct nuclei_in_jets { registryQC.fill(HIST("pt_leading"), pt_max); // Selection of Events with pt > pt_leading - if (static_castparticle_ID.size() < 2) + if (particle_ID.size() < 2) return; if (pt_max < min_pt_leading) return; @@ -322,7 +322,7 @@ struct nuclei_in_jets { int label_jet_particle(0); int i_jet_particle(0); - for (int i = 0; i < static_castparticle_ID.size(); i++) { + for (int i = 0; i < particle_ID.size(); i++) { // Skip Leading Particle & Elements already associated to the Jet if (particle_ID[i] == leading_ID || particle_ID[i] == -1) @@ -372,7 +372,7 @@ struct nuclei_in_jets { nPartAssociated++; } - if (nPartAssociated >= (static_castparticle_ID.size() - 1)) + if (nPartAssociated >= (particle_ID.size() - 1)) exit = 1; if (distance_jet_min > distance_bkg_min) exit = 2; @@ -393,7 +393,7 @@ struct nuclei_in_jets { // Store UE vector ue_particle_ID; - for (int i = 0; i < static_castparticle_ID.size(); i++) { + for (int i = 0; i < particle_ID.size(); i++) { // Skip Leading Particle & Elements already associated to the Jet if (particle_ID[i] == leading_ID || particle_ID[i] == -1) @@ -423,14 +423,14 @@ struct nuclei_in_jets { ue_particle_ID.push_back(particle_ID[i]); } } - registryQC.fill(HIST("ue_multiplicity"), static_castue_particle_ID.size() / 4); + registryQC.fill(HIST("ue_multiplicity"), ue_particle_ID.size() / 4); // Jet Multiplicity - int jet_Nch = static_castjet_particle_ID.size() - static_castue_particle_ID.size() / 4; + int jet_Nch = jet_particle_ID.size() - ue_particle_ID.size() / 4; registryQC.fill(HIST("jet_multiplicity"), jet_Nch); // Loop over particles inside Jet - for (int i = 0; i < static_castjet_particle_ID.size(); i++) { + for (int i = 0; i < jet_particle_ID.size(); i++) { auto jet_track = tracks.iteratorAt(jet_particle_ID[i]); TVector3 p_i(jet_track.px(), jet_track.py(), jet_track.pz()); @@ -476,7 +476,7 @@ struct nuclei_in_jets { } // Loop over particles inside UE - for (int i = 0; i < static_castue_particle_ID.size(); i++) { + for (int i = 0; i < ue_particle_ID.size(); i++) { auto ue_track = tracks.iteratorAt(ue_particle_ID[i]);