From 88dcd582e063039d26028345c2040bbcfe71cbcc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Thu, 30 May 2024 18:41:39 +0200 Subject: [PATCH 01/14] Add task for angular correlations in jets --- .../Nuspex/AngularCorrelationsInJets.cxx | 108 ++++++++++++++++++ PWGLF/Tasks/Nuspex/CMakeLists.txt | 5 + 2 files changed, 113 insertions(+) create mode 100644 PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx new file mode 100644 index 00000000000..42c210e8c8f --- /dev/null +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -0,0 +1,108 @@ +// 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. +// +// Authors: Lars Jörgensen +// Date: 29.05.2024 + +#include +#include +#include +#include + +#include "ReconstructionDataFormats/Track.h" +#include "Framework/AnalysisTask.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/ASoAHelpers.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Framework/runDataProcessing.h" +#include "Framework/HistogramRegistry.h" +#include "PWGDQ/DataModel/ReducedInfoTables.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; + +struct AngularCorrelationsInJets { + + // HistogramRegistry registryName{"folderTitle", {}, OutputObjHandlingPolicy::AnalysisObject, , }; + HistogramRegistry jetOutputReg{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry nucleiOutputReg{"nucleiOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry correlationsOutputReg{"correlationsOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; + + void init(o2::framework::InitContext&) + { + + std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; + + // AxisSpec specName = {binningInfo, "axisLabel"}; + AxisSpec ptAxis = {ptBinning, "#it{p}_{T} (GeV/#it{c})"}; + + // registryName.add("histogramName", "histogramTitle", HistType::Type, {{binningInfo}}); + + jetOutputReg.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); + jetOutputReg.add("hNumPartInEvent", "Number of particles per event", HistType::kTH1I, {{500,0,500}}); + } + + // Configurable cfgName{"nameOnHyperloop", value, "Flag shown on hyperloop"}; + Configurable ptMin{"ptMin", 0.5, "Minimum pT for particles"} + Configurable yMin_gen{"yMin_gen", -0.5, "Maximum rapidity (generated)"}; + Configurable yMax_gen{"yMax_gen", 0.5, "Minimum rapidity (generated)"}; + Configurable cfgCutVertex{"cfgCutVertex", 10.0f, "Accepted z-vertex range"}; + Configurable cfgCutEta{"cfgCutEta", 0.9f, "Eta range for tracks"}; + Configurable yMin_reco{"yMin_reco", -0.5, "Maximum rapidity (reconstructed)"}; + Configurable yMax_reco{"yMax_reco", 0.5, "Minimum rapidity (reconstructed)"}; + Configurable pTmin_reco{"pTmin_reco", 0.1f, "min pT (reconstructed)"}; + Configurable pTmax_reco{"pTmax_reco", 1e+10f, "max pT (reconstructed)"}; + Configurable minReqClusterITS{"minReqClusterITS", 1.0, "min number of clusters required in ITS"}; + Configurable minReqClusterITSib{"minReqClusterITSib", 1.0, "min number of clusters required in ITS inner barrel"}; + Configurable minTPCnClsFound{"minTPCnClsFound", 0.0f, "min number of crossed rows TPC"}; + Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; + Configurable minRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.8f, "min ratio of crossed rows over findable clusters TPC"}; + Configurable maxRatioCrossedRowsTPC{"maxRatioCrossedRowsTPC", 1.5f, "max ratio of crossed rows over findable clusters TPC"}; + Configurable maxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; + Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; + Configurable maxDCA_XY{"maxDCA_XY", 0.5f, "max DCA to vertex xy"}; + Configurable maxDCA_Z{"maxDCA_Z", 2.0f, "max DCA to vertex z"}; + + //**************************************************************************************************** + + template + void processJetReco(const CollisionType& collision, const TracksType& tracks) + { + jetOutputReg.fill(HIST("hNumPartInEvent"), collision.); + + for (const auto& track : tracks) { + if (track.pt() const& tracks) + { + processJetReco(collision, tracks); + } + PROCESS_SWITCH(AngularCorrelationsInJets, processJetReco, "reconstruct jets", true); +}; + +//**************************************************************************************************** + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc, TaskName{"angular-correlations-in-jets"})}; +} diff --git a/PWGLF/Tasks/Nuspex/CMakeLists.txt b/PWGLF/Tasks/Nuspex/CMakeLists.txt index 80455558a8a..30a8817ced8 100644 --- a/PWGLF/Tasks/Nuspex/CMakeLists.txt +++ b/PWGLF/Tasks/Nuspex/CMakeLists.txt @@ -133,3 +133,8 @@ o2physics_add_dpl_workflow(nuclei-ebye SOURCES nucleiEbye.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(angular-correlations-in-jets + SOURCES AngularCorrelationsInJets.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) \ No newline at end of file From 47c5d3bb4c1d1ef6c4938f6a9a56a99cf483db8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Thu, 30 May 2024 23:03:27 +0200 Subject: [PATCH 02/14] Added configurables --- .../Nuspex/AngularCorrelationsInJets.cxx | 85 +++++++++++++------ 1 file changed, 60 insertions(+), 25 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index 42c210e8c8f..7295f4c5c0b 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -55,33 +55,68 @@ struct AngularCorrelationsInJets { } // Configurable cfgName{"nameOnHyperloop", value, "Flag shown on hyperloop"}; - Configurable ptMin{"ptMin", 0.5, "Minimum pT for particles"} - Configurable yMin_gen{"yMin_gen", -0.5, "Maximum rapidity (generated)"}; - Configurable yMax_gen{"yMax_gen", 0.5, "Minimum rapidity (generated)"}; - Configurable cfgCutVertex{"cfgCutVertex", 10.0f, "Accepted z-vertex range"}; - Configurable cfgCutEta{"cfgCutEta", 0.9f, "Eta range for tracks"}; - Configurable yMin_reco{"yMin_reco", -0.5, "Maximum rapidity (reconstructed)"}; - Configurable yMax_reco{"yMax_reco", 0.5, "Minimum rapidity (reconstructed)"}; - Configurable pTmin_reco{"pTmin_reco", 0.1f, "min pT (reconstructed)"}; - Configurable pTmax_reco{"pTmax_reco", 1e+10f, "max pT (reconstructed)"}; - Configurable minReqClusterITS{"minReqClusterITS", 1.0, "min number of clusters required in ITS"}; - Configurable minReqClusterITSib{"minReqClusterITSib", 1.0, "min number of clusters required in ITS inner barrel"}; - Configurable minTPCnClsFound{"minTPCnClsFound", 0.0f, "min number of crossed rows TPC"}; - Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; - Configurable minRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.8f, "min ratio of crossed rows over findable clusters TPC"}; - Configurable maxRatioCrossedRowsTPC{"maxRatioCrossedRowsTPC", 1.5f, "max ratio of crossed rows over findable clusters TPC"}; - Configurable maxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; - Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; - Configurable maxDCA_XY{"maxDCA_XY", 0.5f, "max DCA to vertex xy"}; - Configurable maxDCA_Z{"maxDCA_Z", 2.0f, "max DCA to vertex z"}; + Configurable ptMin{"ptMin", 0.5, "Minimum pT for particles"}; + + // Preliminary Cuts + Configurable TPCRefit{"TPCRefit", false, "Require TPC refit"}; + Configurable fITSRefit{"ITSRefit", false, "Require ITS refit"}; + Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; + Configurable fMinReqClusterITS{"minReqClusterITS", 2.0, "min number of clusters required in ITS"}; + Configurable fMinRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.7f, "min ratio of crossed rows over findable clusters TPC"}; + Configurable fMaxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; + Configurable fMaxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; + Configurable fMaxDCA_xy{"maxDCA_xy", 0.5f, "max DCA to vertex xy"}; + Configurable fMaxDCA_z{"maxDCA_z", 2.4f, "max DCA to vertex z"}; + Configurable fMaxEta{"maxEta", 0.8, "max pseudorapidity"}; + + // Jet Cuts + Configurable fJetRadius{"jetRadius", 0.4, "jet radius R"}; + Configurable fMinJetPt{"minJetPt", 10.0, "minimum total pT to accept jet"}; + Configurable fMinJetParticlePt{"minJetParticlePt", 0.0, "minimum pT to accept jet particle"}; + Configurable fMinLeadingPt{"minLeadingPt", 5.0, "minimum pT for leading track"}; + + // Proton Cuts + Configurable fProtonDCAxy{"protonDCAxy", 0.5, "[proton] DCAxy cut"}; + Configurable fProtonDCAz{"protonDCAz", 1.0, "[proton] DCAz cut"}; + Configurable fProtonITSTOFpT{"protonITSTOFswitchpT", 0.7, "[proton] pT for switch between ITS+TPC/TPC+TOF"}; + Configurable fProtonITSnsig{"protonITSnsigma", 3.0, "[proton] max ITS nsigma"}; + Configurable fProtonTPCnsigITS{"protonTPCnsigmaIfITS", 5.0, "[proton] max TPC nsigma with ITS"}; + Configurable fProtonTPCnsigTOF{"protonTPCnsigmaIfTOF", 4.0, "[proton] max TPC nsigma with TOF"}; + Configurable fProtonTOFnsig{"protonTOFnsigma", 10.0, "[proton] max TOF nsigma"}; + + // Antiproton Cuts + Configurable fAntiprotonDCAxy{"antiprotonDCAxy", 0.5, "[antiproton] DCAxy cut"}; + Configurable fAntiprotonDCAz{"antiprotonDCAz", 1.0, "[antiproton] DCAz cut"}; + Configurable fAntiprotonITSTOFpT{"antiprotonITSTOFswitchpT", 0.7, "[antiproton] pT for switch between ITS+TPC/TPC+TOF"}; + Configurable fAntiprotonITSnsig{"antiprotonITSnsigma", 3.0, "[antiproton] max ITS nsigma"}; + Configurable fAntiprotonTPCnsigITS{"antiprotonTPCnsigmaIfITS", 5.0, "[antiproton] max TPC nsigma with ITS"}; + Configurable fAntiprotonTPCnsigTOF{"antiprotonTPCnsigmaIfTOF", 4.0, "[antiproton] max TPC nsigma with TOF"}; + Configurable fAntiprotonTOFnsig{"antiprotonTOFnsigma", 10.0, "[antiproton] max TOF nsigma"}; + + // Deuteron Cuts + Configurable fDeuteronDCAxy{"deuteronDCAxy", 0.5, "[deuteron] DCAxy cut"}; + Configurable fDeuteronDCAz{"deuteronDCAz", 1.0, "[deuteron] DCAz cut"}; + Configurable fDeuteronITSTOFpT{"deuteronITSTOFswitchpT", 0.7, "[deuteron] pT for switch between ITS+TPC/TPC+TOF"}; + Configurable fDeuteronITSnsig{"deuteronITSnsigma", 3.0, "[deuteron] max ITS nsigma"}; + Configurable fDeuteronTPCnsigITS{"deuteronTPCnsigmaIfITS", 5.0, "[deuteron] max TPC nsigma with ITS"}; + Configurable fDeuteronTPCnsigTOF{"deuteronTPCnsigmaIfTOF", 4.0, "[deuteron] max TPC nsigma with TOF"}; + Configurable fDeuteronTOFnsig{"deuteronTOFnsigma", 10.0, "[deuteron] max TOF nsigma"}; + + // Antideuteron Cuts + Configurable fAntideuteronDCAxy{"antideuteronDCAxy", 0.5, "[antideuteron] DCAxy cut"}; + Configurable fAntideuteronDCAz{"antideuteronDCAz", 1.0, "[antideuteron] DCAz cut"}; + Configurable fAntideuteronITSTOFpT{"antideuteronITSTOFswitchpT", 0.7, "[antideuteron] pT for switch between ITS+TPC/TPC+TOF"}; + Configurable fAntideuteronITSnsig{"antideuteronITSnsigma", 3.0, "[antideuteron] max ITS nsigma"}; + Configurable fAntideuteronTPCnsigITS{"antideuteronTPCnsigmaIfITS", 5.0, "[antideuteron] max TPC nsigma with ITS"}; + Configurable fAntideuteronTPCnsigTOF{"antideuteronTPCnsigmaIfTOF", 4.0, "[antideuteron] max TPC nsigma with TOF"}; + Configurable fAntideuteronTOFnsig{"antideuteronTOFnsigma", 10.0, "[antideuteron] max TOF nsigma"}; + //**************************************************************************************************** template - void processJetReco(const CollisionType& collision, const TracksType& tracks) + void jetReco(const CollisionType& collision, const TracksType& tracks) { - jetOutputReg.fill(HIST("hNumPartInEvent"), collision.); - for (const auto& track : tracks) { if (track.pt() const& tracks) + void process_jet_reco(aod::Collision const& collision, soa::Join const& tracks) { - processJetReco(collision, tracks); + jetReco(collision, tracks); } - PROCESS_SWITCH(AngularCorrelationsInJets, processJetReco, "reconstruct jets", true); + PROCESS_SWITCH(AngularCorrelationsInJets, process_jet_reco, "reconstruct jets", true); }; //**************************************************************************************************** From 65f541aa334f96454f2885c437f0cd95879c20aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Thu, 30 May 2024 23:29:06 +0200 Subject: [PATCH 03/14] Added FastJet modules and libraries --- PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx | 14 ++++++++++++-- PWGLF/Tasks/Nuspex/CMakeLists.txt | 10 ++++++---- 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index 7295f4c5c0b..e7669fb2306 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -27,6 +27,13 @@ #include "Framework/runDataProcessing.h" #include "Framework/HistogramRegistry.h" #include "PWGDQ/DataModel/ReducedInfoTables.h" +#include "fastjet/PseudoJet.hh" +#include "fastjet/AreaDefinition.hh" +#include "fastjet/ClusterSequenceArea.hh" +#include "fastjet/GhostedAreaSpec.hh" +#include "fastjet/Selector.hh" +#include "fastjet/tools/Subtractor.hh" +#include "fastjet/tools/JetMedianBackgroundEstimator.hh" using namespace o2; using namespace o2::framework; @@ -46,7 +53,10 @@ struct AngularCorrelationsInJets { std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; // AxisSpec specName = {binningInfo, "axisLabel"}; - AxisSpec ptAxis = {ptBinning, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec ptAxis = {ptBinning, "#it{p}_{T} [GeV/#it{c}]"}; + AxisSpec particleTypeAxis = {4,1,5, "[p, ap, d, ad]"}; + AxisSpec nsigmapTAxis = {1000,-50,50, "#it{p}_{T} [GeV/#it{c}]"}; + AxisSpec nsigmaAxis = {1000,-5,5, "n#sigma"}; // registryName.add("histogramName", "histogramTitle", HistType::Type, {{binningInfo}}); @@ -127,7 +137,7 @@ struct AngularCorrelationsInJets { //**************************************************************************************************** - void process_jet_reco(aod::Collision const& collision, soa::Join const& tracks) + void process_jet_reco(aod::Collision const& collision, soa::Join const& tracks) { jetReco(collision, tracks); } diff --git a/PWGLF/Tasks/Nuspex/CMakeLists.txt b/PWGLF/Tasks/Nuspex/CMakeLists.txt index 30a8817ced8..446b5cd7a31 100644 --- a/PWGLF/Tasks/Nuspex/CMakeLists.txt +++ b/PWGLF/Tasks/Nuspex/CMakeLists.txt @@ -134,7 +134,9 @@ o2physics_add_dpl_workflow(nuclei-ebye PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) -o2physics_add_dpl_workflow(angular-correlations-in-jets - SOURCES AngularCorrelationsInJets.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore - COMPONENT_NAME Analysis) \ No newline at end of file +if(FastJet_FOUND) + o2physics_add_dpl_workflow(angular-correlations-in-jets + SOURCES AngularCorrelationsInJets.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore FastJet::FastJet FastJet::Contrib + COMPONENT_NAME Analysis) +endif() \ No newline at end of file From b45d0a55f28a76f2211d57903df23eb68a671826 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Fri, 31 May 2024 00:26:49 +0200 Subject: [PATCH 04/14] added rudimentary preliminary track filter --- .../Nuspex/AngularCorrelationsInJets.cxx | 25 ++++++++++--------- PWGLF/Tasks/Nuspex/CMakeLists.txt | 8 +++--- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index e7669fb2306..c433de373ec 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -13,7 +13,7 @@ // Date: 29.05.2024 #include -#include +#include #include #include @@ -21,11 +21,10 @@ #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" #include "Framework/ASoAHelpers.h" -#include "Common/DataModel/TrackSelectionTables.h" -#include "Common/DataModel/EventSelection.h" -#include "Common/DataModel/Centrality.h" #include "Framework/runDataProcessing.h" #include "Framework/HistogramRegistry.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "Common/DataModel/EventSelection.h" #include "PWGDQ/DataModel/ReducedInfoTables.h" #include "fastjet/PseudoJet.hh" #include "fastjet/AreaDefinition.hh" @@ -39,12 +38,13 @@ using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; +using SelectedCollisions = soa::Join; +using FullTracks = soa::Join; + struct AngularCorrelationsInJets { // HistogramRegistry registryName{"folderTitle", {}, OutputObjHandlingPolicy::AnalysisObject, , }; - HistogramRegistry jetOutputReg{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; - HistogramRegistry nucleiOutputReg{"nucleiOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; - HistogramRegistry correlationsOutputReg{"correlationsOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; void init(o2::framework::InitContext&) @@ -60,15 +60,15 @@ struct AngularCorrelationsInJets { // registryName.add("histogramName", "histogramTitle", HistType::Type, {{binningInfo}}); - jetOutputReg.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); - jetOutputReg.add("hNumPartInEvent", "Number of particles per event", HistType::kTH1I, {{500,0,500}}); + registryData.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); + registryData.add("hNumPartInEvent", "Number of particles per event", HistType::kTH1I, {{500,0,500}}); } // Configurable cfgName{"nameOnHyperloop", value, "Flag shown on hyperloop"}; Configurable ptMin{"ptMin", 0.5, "Minimum pT for particles"}; // Preliminary Cuts - Configurable TPCRefit{"TPCRefit", false, "Require TPC refit"}; + Configurable fTPCRefit{"TPCRefit", false, "Require TPC refit"}; Configurable fITSRefit{"ITSRefit", false, "Require ITS refit"}; Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; Configurable fMinReqClusterITS{"minReqClusterITS", 2.0, "min number of clusters required in ITS"}; @@ -131,13 +131,14 @@ struct AngularCorrelationsInJets { if (track.pt() const& tracks) + Filter prelimTrackCuts = (aod::track::TPCrefit == fTPCRefit && aod::track::ITSrefit == fITSRefit && aod::track::itsChi2NCl < fMaxChi2ITS && aod::track::tpcChi2NCl < fMaxChi2TPC); // refits are int + void process_jet_reco(aod::Collision const& collision, soa::Filtered> const& tracks) { jetReco(collision, tracks); } diff --git a/PWGLF/Tasks/Nuspex/CMakeLists.txt b/PWGLF/Tasks/Nuspex/CMakeLists.txt index 446b5cd7a31..a69ac7d6743 100644 --- a/PWGLF/Tasks/Nuspex/CMakeLists.txt +++ b/PWGLF/Tasks/Nuspex/CMakeLists.txt @@ -135,8 +135,8 @@ o2physics_add_dpl_workflow(nuclei-ebye COMPONENT_NAME Analysis) if(FastJet_FOUND) - o2physics_add_dpl_workflow(angular-correlations-in-jets - SOURCES AngularCorrelationsInJets.cxx - PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore FastJet::FastJet FastJet::Contrib - COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(angular-correlations-in-jets + SOURCES AngularCorrelationsInJets.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore FastJet::FastJet FastJet::Contrib + COMPONENT_NAME Analysis) endif() \ No newline at end of file From 76bedc68154b21d203534fd6440d160a2aa769c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Fri, 31 May 2024 20:06:14 +0200 Subject: [PATCH 05/14] Added histograms and jet reconstruction/background subtraction --- .../Nuspex/AngularCorrelationsInJets.cxx | 160 +++++++++++++----- 1 file changed, 121 insertions(+), 39 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index c433de373ec..28b147994e9 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -13,6 +13,7 @@ // Date: 29.05.2024 #include +#include #include #include #include @@ -21,10 +22,10 @@ #include "Framework/AnalysisTask.h" #include "Framework/AnalysisDataModel.h" #include "Framework/ASoAHelpers.h" -#include "Framework/runDataProcessing.h" -#include "Framework/HistogramRegistry.h" #include "Common/DataModel/TrackSelectionTables.h" #include "Common/DataModel/EventSelection.h" +#include "Framework/runDataProcessing.h" +#include "Framework/HistogramRegistry.h" #include "PWGDQ/DataModel/ReducedInfoTables.h" #include "fastjet/PseudoJet.hh" #include "fastjet/AreaDefinition.hh" @@ -38,45 +39,83 @@ using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; -using SelectedCollisions = soa::Join; -using FullTracks = soa::Join; +// using SelectedCollisions = soa::Join; +using FullTracks = soa::Join; struct AngularCorrelationsInJets { // HistogramRegistry registryName{"folderTitle", {}, OutputObjHandlingPolicy::AnalysisObject, , }; - HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; - void init(o2::framework::InitContext&) - { + void init(o2::framework::InitContext&) { - std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; + // std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; // AxisSpec specName = {binningInfo, "axisLabel"}; - AxisSpec ptAxis = {ptBinning, "#it{p}_{T} [GeV/#it{c}]"}; + AxisSpec ptAxis = {1000,0,100, "#it{p}_{T} [GeV/#it{c}]"}; AxisSpec particleTypeAxis = {4,1,5, "[p, ap, d, ad]"}; - AxisSpec nsigmapTAxis = {1000,-50,50, "#it{p}_{T} [GeV/#it{c}]"}; - AxisSpec nsigmaAxis = {1000,-5,5, "n#sigma"}; + AxisSpec nsigmapTAxis = {1000,-50,50, "#it{p}_{T} [GeV/#it{c}]"}; + AxisSpec nsigmaAxis = {1000,-5,5, "n#sigma"}; + AxisSpec dcazAxis = {200,-3,3, "DCA_{z} [cm]"}; + AxisSpec dcaxyAxis = {200,-2,2, "DCA_{xy} [cm]"}; + AxisSpec angDistPhiAxis = {1000,-2,5, "#Delta#varphi"}; + AxisSpec angDistEtaAxis = {1000,-2,2, "#Delta#eta"}; // registryName.add("histogramName", "histogramTitle", HistType::Type, {{binningInfo}}); - - registryData.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); - registryData.add("hNumPartInEvent", "Number of particles per event", HistType::kTH1I, {{500,0,500}}); - } - // Configurable cfgName{"nameOnHyperloop", value, "Flag shown on hyperloop"}; + // Counters + registryData.add("hNumberOfEvents", "Number of events", HistType::kTH1I, {{1,0,1}}); + registryData.add("hNumberOfJets", "Total number of jets", HistType::kTH1I, {{1,0,1}}); + registryData.add("hEventProtocol", "Event protocol", HistType::kTH1I, {{20,0,20}}); + registryData.add("hTrackProtocol", "Track protocol", HistType::kTH1I, {{20,0,20}}); + registryData.add("hNumPartInJet", "Number of particles in a jet", HistType::kTH1I, {{200,0,200}}); + + // (Pseudo)Rapidity + registryData.add("hEtaFullEvent", "Particle pseudorapidity;#eta", HistType::kTH1F, {{200,-1,1}}); + registryData.add("hJetRapidity", "Jet rapidity;#it{y}", HistType::kTH1F, {{200,-1,1}}); + + // pT + registryData.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); + registryData.add("hPtJetParticle", "p_{T} of particles in jets", HistType::kTH1F, {ptAxis}); + registryData.add("hPtSubtractedJet", "Subtracted jet p_{T}", HistType::kTH1F, {ptAxis}); + registryData.add("hPtJetProtonDeuteron", "p_{T} of (anti)p, (anti)d", HistType::kTH2F, {particleTypeAxis, ptAxis}); + registryData.add("hPtTotalJet", "p_{T} of entire jet;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1F, {{2000,0,500}}); + registryData.add("hPtDiff", "pT difference PseudoJet/original track;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1D, {{100,-0.0000005,0.0000005}}); + + // nSigma + registryData.add("hTPCnsigmaProton", "TPC n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTOFnsigmaProton", "TOF n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hITSnsigmaProton", "ITS n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTPCnsigmaDeuteron", "TPC n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTOFnsigmaDeuteron", "TOF n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hITSnsigmaDeuteron", "ITS n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + + // DCA + registryData.add("hDCAxyFullEvent", "DCA xy of full event", HistType::kTH1F, {dcaxyAxis}); + registryData.add("hDCAzFullEvent", "Number of events", HistType::kTH1I, {dcazAxis}); + registryData.add("hDCAzJetParticle", "Number of events", HistType::kTH1I, {dcazAxis}); + + // Angular Distributions + registryData.add("hDeltaPhiSE", "#Delta#varphi of (anti)p, (anti)d in single event", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); + registryData.add("hDeltaPhiME", "#Delta#varphi of (anti)p, (anti)d in mixed events", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); + registryData.add("hDeltaPhiEtaSE", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in single event", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); + registryData.add("hDeltaPhiEtaME", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in mixed events", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); + } + + // Configurable cfgName{"nameOnHyperloopAndJson", value, "Flag shown on hyperloop"}; Configurable ptMin{"ptMin", 0.5, "Minimum pT for particles"}; // Preliminary Cuts - Configurable fTPCRefit{"TPCRefit", false, "Require TPC refit"}; - Configurable fITSRefit{"ITSRefit", false, "Require ITS refit"}; - Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; + Configurable fTPCRefit{"TPCRefit", 0, "Require TPC refit"}; + Configurable fITSRefit{"ITSRefit", 0, "Require ITS refit"}; + Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; Configurable fMinReqClusterITS{"minReqClusterITS", 2.0, "min number of clusters required in ITS"}; - Configurable fMinRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.7f, "min ratio of crossed rows over findable clusters TPC"}; - Configurable fMaxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; - Configurable fMaxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; - Configurable fMaxDCA_xy{"maxDCA_xy", 0.5f, "max DCA to vertex xy"}; - Configurable fMaxDCA_z{"maxDCA_z", 2.4f, "max DCA to vertex z"}; + Configurable fMinRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.7f, "min ratio of crossed rows over findable clusters TPC"}; + Configurable fMaxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; + Configurable fMaxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; + Configurable fMaxDCAxy{"maxDCA_xy", 0.5f, "max DCA to vertex xy"}; + Configurable fMaxDCAz{"maxDCA_z", 2.4f, "max DCA to vertex z"}; Configurable fMaxEta{"maxEta", 0.8, "max pseudorapidity"}; // Jet Cuts @@ -121,24 +160,67 @@ struct AngularCorrelationsInJets { Configurable fAntideuteronTPCnsigTOF{"antideuteronTPCnsigmaIfTOF", 4.0, "[antideuteron] max TPC nsigma with TOF"}; Configurable fAntideuteronTOFnsig{"antideuteronTOFnsigma", 10.0, "[antideuteron] max TOF nsigma"}; + //**************************************************************************************************** + + template + void jetReco(const CollisionType& collision, const TracksType& tracks) { + std::vector jetInput; + std::vector jets; + std::vector constituents; + fastjet::PseudoJet hardestJet(0.,0.,0.,0.); + fastjet::PseudoJet subtractedJet(0.,0.,0.,0.); + jetInput.clear(); + jets.clear(); + constituents.clear(); + + for (const auto& track : tracks) { + if (track.pt() - void jetReco(const CollisionType& collision, const TracksType& tracks) - { - for (const auto& track : tracks) { - if (track.pt()> const& tracks) + Filter prelimTrackCuts = (aod::track::TPCrefit == fTPCRefit && aod::track::ITSrefit == fITSRefit && aod::track::itsChi2NCl < fMaxChi2ITS && aod::track::tpcChi2NCl < fMaxChi2TPC && nabs(aod::track::dcaXY) < fMaxDCAxy && nabs(aod::track::dcaZ) < fMaxDCAz && nabs(aod::track::eta) < fMaxEta); // refits are int + void process_jet_reco(aod::Collision const& collision, soa::Filtered const& tracks) { jetReco(collision, tracks); } From adf4ccf8d00587647ad50178ecf1bc2c05f5697b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Tue, 4 Jun 2024 11:53:44 +0200 Subject: [PATCH 06/14] Added remaining task logic --- .../Nuspex/AngularCorrelationsInJets.cxx | 301 ++++++++++++++++-- 1 file changed, 282 insertions(+), 19 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index 28b147994e9..a3f216eb69b 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -13,7 +13,6 @@ // Date: 29.05.2024 #include -#include #include #include #include @@ -27,6 +26,7 @@ #include "Framework/runDataProcessing.h" #include "Framework/HistogramRegistry.h" #include "PWGDQ/DataModel/ReducedInfoTables.h" +#include "PWGLF/DataModel/LFParticleIdentification.h" #include "fastjet/PseudoJet.hh" #include "fastjet/AreaDefinition.hh" #include "fastjet/ClusterSequenceArea.hh" @@ -34,13 +34,14 @@ #include "fastjet/Selector.hh" #include "fastjet/tools/Subtractor.hh" #include "fastjet/tools/JetMedianBackgroundEstimator.hh" +#include "TVector2.h" using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; // using SelectedCollisions = soa::Join; -using FullTracks = soa::Join; +using FullTracks = soa::Join; struct AngularCorrelationsInJets { @@ -48,7 +49,7 @@ struct AngularCorrelationsInJets { HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; - void init(o2::framework::InitContext&) { + void init(InitContext&) { // std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; @@ -86,15 +87,15 @@ struct AngularCorrelationsInJets { // nSigma registryData.add("hTPCnsigmaProton", "TPC n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTOFnsigmaProton", "TOF n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - registryData.add("hITSnsigmaProton", "ITS n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + // registryData.add("hITSnsigmaProton", "ITS n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTPCnsigmaDeuteron", "TPC n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTOFnsigmaDeuteron", "TOF n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - registryData.add("hITSnsigmaDeuteron", "ITS n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + // registryData.add("hITSnsigmaDeuteron", "ITS n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); // DCA - registryData.add("hDCAxyFullEvent", "DCA xy of full event", HistType::kTH1F, {dcaxyAxis}); - registryData.add("hDCAzFullEvent", "Number of events", HistType::kTH1I, {dcazAxis}); - registryData.add("hDCAzJetParticle", "Number of events", HistType::kTH1I, {dcazAxis}); + registryData.add("hDCAxyFullEvent", "DCA_{xy} of full event", HistType::kTH1F, {dcaxyAxis}); + registryData.add("hDCAzFullEvent", "DCA_{z} of full event", HistType::kTH1F, {dcazAxis}); + registryData.add("hDCAzJetParticle", "DCA_{z} of jet particles", HistType::kTH1F, {dcazAxis}); // Angular Distributions registryData.add("hDeltaPhiSE", "#Delta#varphi of (anti)p, (anti)d in single event", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); @@ -104,11 +105,9 @@ struct AngularCorrelationsInJets { } // Configurable cfgName{"nameOnHyperloopAndJson", value, "Flag shown on hyperloop"}; - Configurable ptMin{"ptMin", 0.5, "Minimum pT for particles"}; - // Preliminary Cuts - Configurable fTPCRefit{"TPCRefit", 0, "Require TPC refit"}; - Configurable fITSRefit{"ITSRefit", 0, "Require ITS refit"}; + // Configurable fTPCRefit{"TPCRefit", 0, "Require TPC refit"}; + // Configurable fITSRefit{"ITSRefit", 0, "Require ITS refit"}; Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; Configurable fMinReqClusterITS{"minReqClusterITS", 2.0, "min number of clusters required in ITS"}; Configurable fMinRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.7f, "min ratio of crossed rows over findable clusters TPC"}; @@ -160,10 +159,19 @@ struct AngularCorrelationsInJets { Configurable fAntideuteronTPCnsigTOF{"antideuteronTPCnsigmaIfTOF", 4.0, "[antideuteron] max TPC nsigma with TOF"}; Configurable fAntideuteronTOFnsig{"antideuteronTOFnsigma", 10.0, "[antideuteron] max TOF nsigma"}; + Configurable fTrackBufferSize{"trackBufferSize", 2000, "Number of mixed-event tracks being stored"}; + + std::vector fTrackBufferProton; + std::vector fTrackBufferAntiproton; + std::vector fTrackBufferDeuteron; + std::vector fTrackBufferAntideuteron; + //**************************************************************************************************** template - void jetReco(const CollisionType& collision, const TracksType& tracks) { + void jetReco(const CollisionType& collision, const TracksType& tracks) { // this turns TracksType into a pointer, no? How then can we access attributes with . instead of ->? + registryData.fill(HIST("hNumberOfEvents"), 0); + std::vector jetInput; std::vector jets; std::vector constituents; @@ -174,11 +182,10 @@ struct AngularCorrelationsInJets { constituents.clear(); for (const auto& track : tracks) { - if (track.pt() jetProtons; + std::vector jetAntiprotons; + std::vector jetDeuterons; + std::vector jetAntideuterons; + + for (int i=0; i<(int)constituents.size(); i++) { + fastjet::PseudoJet pseudoParticle = constituents[i]; + int id = pseudoParticle.user_index(); + typename TracksType::iterator jetParticle = tracks.iteratorAt(id); + double ptDiff = pseudoParticle.pt() - jetParticle.pt(); + registryData.fill(HIST("hPtDiff"), ptDiff); + int particleType = 0; + + registryData.fill(HIST("hDCAzJetParticle"), jetParticle.dcaZ()); + if (jetParticle.pt()1) { + for (int i=0; i<(int)jetProtons.size(); i++) { + for (int j=i+1; j<(int)jetProtons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetProtons[i].phi() - jetProtons[j].phi()); + double DeltaEta = TMath::Abs(jetProtons[i].eta() - jetProtons[j].eta()); + if (DeltaPhi>(1.5*TMath::Pi())) { + DeltaPhi = DeltaPhi - 2*TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 1, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 1, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetProtons[i], 1); + SetTrackBuffer(jetProtons[i], 1); + } + } + if (jetAntiprotons.size()>1) { + for (int i=0; i<(int)jetAntiprotons.size(); i++) { + for (int j=i+1; j<(int)jetAntiprotons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetAntiprotons[i].phi() - jetAntiprotons[j].phi()); + double DeltaEta = TMath::Abs(jetAntiprotons[i].eta() - jetAntiprotons[j].eta()); + if (DeltaPhi>(1.5*TMath::Pi())) { + DeltaPhi = DeltaPhi - 2*TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 2, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 2, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetAntiprotons[i], 2); + SetTrackBuffer(jetAntiprotons[i], 2); + } + } + if (jetDeuterons.size()>1) { + for (int i=0; i<(int)jetDeuterons.size(); i++) { + for (int j=i+1; j<(int)jetDeuterons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetDeuterons[i].phi() - jetDeuterons[j].phi()); + double DeltaEta = TMath::Abs(jetDeuterons[i].eta() - jetDeuterons[j].eta()); + if (DeltaPhi>(1.5*TMath::Pi())) { + DeltaPhi = DeltaPhi - 2*TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 3, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 3, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetDeuterons[i], 3); + SetTrackBuffer(jetDeuterons[i], 3); + } + } + if (jetAntideuterons.size()>1) { + for (int i=0; i<(int)jetAntideuterons.size(); i++) { + for (int j=i+1; j<(int)jetAntideuterons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetAntideuterons[i].phi() - jetAntideuterons[j].phi()); + double DeltaEta = TMath::Abs(jetAntideuterons[i].eta() - jetAntideuterons[j].eta()); + if (DeltaPhi>(1.5*TMath::Pi())) { + DeltaPhi = DeltaPhi - 2*TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 4, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 4, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetAntideuterons[i], 4); + SetTrackBuffer(jetAntideuterons[i], 4); + } + } + } + + template + bool IsProton(const T1& track) { + bool isProton = false; + if (track.sign()<0) return isProton; + + if (TMath::Abs(track.dcaXY()) > fProtonDCAxy) return isProton; + if (TMath::Abs(track.dcaZ()) > fProtonDCAz) return isProton; + + if (track.pt()fProtonITSTOFpT && TMath::Abs(track.tpcNSigmaPr()) + bool IsAntiproton(const T2& track) { + bool isAntiproton = false; + if (track.sign()<0) return isAntiproton; + + if (TMath::Abs(track.dcaXY()) > fAntiprotonDCAxy) return isAntiproton; + if (TMath::Abs(track.dcaZ()) > fAntiprotonDCAz) return isAntiproton; + + if (track.pt()fAntiprotonITSTOFpT && TMath::Abs(track.tpcNSigmaPr()) + bool IsDeuteron(const T3& track) { + bool isDeuteron = false; + if (track.sign()<0) return isDeuteron; + + if (TMath::Abs(track.dcaXY()) > fDeuteronDCAxy) return isDeuteron; + if (TMath::Abs(track.dcaZ()) > fDeuteronDCAz) return isDeuteron; + + if (track.pt()fDeuteronITSTOFpT && TMath::Abs(track.tpcNSigmaPr()) + bool IsAntideuteron(const T4& track) { + bool isAntideuteron = false; + if (track.sign()<0) return isAntideuteron; + + if (TMath::Abs(track.dcaXY()) > fAntideuteronDCAxy) return isAntideuteron; + if (TMath::Abs(track.dcaZ()) > fAntideuteronDCAz) return isAntideuteron; + + if (track.pt()fAntideuteronITSTOFpT && TMath::Abs(track.tpcNSigmaDe()) + void SetTrackBuffer(const T5& track, int particleType) { + switch (particleType) { + case 1: + if ((int)fTrackBufferProton.size()==fTrackBufferSize) { + fTrackBufferProton.insert(fTrackBufferProton.begin(), track); + fTrackBufferProton.resize(fTrackBufferSize); + } else if ((int)fTrackBufferProton.size() + void FillMixedEventDeltas(const T6& track, int particleType) { + switch (particleType) { + case 1: + if (fTrackBufferProton.size() == 0) return; + for (int i=0; i<(int)fTrackBufferProton.size(); i++) { // can I do this even if the trackbuffer isn't even full yet? + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferProton[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferProton[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + case 2: + if (fTrackBufferAntiproton.size() == 0) return; + for (int i=0; i<(int)fTrackBufferAntiproton.size(); i++) { + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntiproton[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntiproton[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + case 3: + if (fTrackBufferDeuteron.size() == 0) return; + for (int i=0; i<(int)fTrackBufferDeuteron.size(); i++) { + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferDeuteron[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferDeuteron[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + case 4: + if (fTrackBufferAntideuteron.size() == 0) return; + for (int i=0; i<(int)fTrackBufferAntideuteron.size(); i++) { + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntideuteron[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntideuteron[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + default: + LOG(warn) << "FillMixedEventDeltas: invalid particle ID!"; + } + } //**************************************************************************************************** - Filter prelimTrackCuts = (aod::track::TPCrefit == fTPCRefit && aod::track::ITSrefit == fITSRefit && aod::track::itsChi2NCl < fMaxChi2ITS && aod::track::tpcChi2NCl < fMaxChi2TPC && nabs(aod::track::dcaXY) < fMaxDCAxy && nabs(aod::track::dcaZ) < fMaxDCAz && nabs(aod::track::eta) < fMaxEta); // refits are int + Filter prelimTrackCuts = (/* aod::track::TPCrefit == fTPCRefit && aod::track::ITSrefit == fITSRefit && */aod::track::itsChi2NCl const& tracks) { jetReco(collision, tracks); From 9fef19f56025bf2bda1a0db2d1beeb9b69781530 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Tue, 4 Jun 2024 15:06:59 +0200 Subject: [PATCH 07/14] Added remaining histograms --- .../Nuspex/AngularCorrelationsInJets.cxx | 53 +++++++++++++------ 1 file changed, 37 insertions(+), 16 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index a3f216eb69b..4087926229e 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -46,7 +46,7 @@ using FullTracks = soa::Join, }; - HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; void init(InitContext&) { @@ -78,13 +78,16 @@ struct AngularCorrelationsInJets { // pT registryData.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); - registryData.add("hPtJetParticle", "p_{T} of particles in jets", HistType::kTH1F, {ptAxis}); - registryData.add("hPtSubtractedJet", "Subtracted jet p_{T}", HistType::kTH1F, {ptAxis}); - registryData.add("hPtJetProtonDeuteron", "p_{T} of (anti)p, (anti)d", HistType::kTH2F, {particleTypeAxis, ptAxis}); + registryData.add("hPtJetParticle", "p_{T} of particles in jets", HistType::kTH1D, {ptAxis}); + registryData.add("hPtSubtractedJet", "Subtracted jet p_{T}", HistType::kTH1D, {ptAxis}); + registryData.add("hPtJetProtonDeuteron", "p_{T} of (anti)p, (anti)d", HistType::kTH2D, {particleTypeAxis, ptAxis}); registryData.add("hPtTotalJet", "p_{T} of entire jet;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1F, {{2000,0,500}}); registryData.add("hPtDiff", "pT difference PseudoJet/original track;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1D, {{100,-0.0000005,0.0000005}}); // nSigma + registryData.add("hTPCnsigma", "TPC n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTOFnsigma", "TOF n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + // registryData.add("hITSnsigma", "ITS n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTPCnsigmaProton", "TPC n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTOFnsigmaProton", "TOF n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); // registryData.add("hITSnsigmaProton", "ITS n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); @@ -102,6 +105,8 @@ struct AngularCorrelationsInJets { registryData.add("hDeltaPhiME", "#Delta#varphi of (anti)p, (anti)d in mixed events", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); registryData.add("hDeltaPhiEtaSE", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in single event", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); registryData.add("hDeltaPhiEtaME", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in mixed events", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); + + registryData.add("hJetConeRadius", "Jet Radius;#it{R}", HistType::kTH1F, {{100,0,1}}); } // Configurable cfgName{"nameOnHyperloopAndJson", value, "Flag shown on hyperloop"}; @@ -171,6 +176,7 @@ struct AngularCorrelationsInJets { template void jetReco(const CollisionType& collision, const TracksType& tracks) { // this turns TracksType into a pointer, no? How then can we access attributes with . instead of ->? registryData.fill(HIST("hNumberOfEvents"), 0); + registryData.fill(HIST("hEventProtocol"), 0); std::vector jetInput; std::vector jets; @@ -183,13 +189,22 @@ struct AngularCorrelationsInJets { for (const auto& track : tracks) { registryData.fill(HIST("hTrackProtocol"), 0); + registryData.fill(HIST("hEtaFullEvent"), track.eta()); registryData.fill(HIST("hPtFullEvent"), track.pt()); + registryData.fill(HIST("hDCAxyFullEvent"), track.dcaXY()); + registryData.fill(HIST("hDCAzFullEvent"), track.dcaZ()); + registryData.fill(HIST("hTPCnsigma"), track.pt()*track.sign(), track.tpcNSigmaPr()); + registryData.fill(HIST("hTOFnsigma"), track.pt()*track.sign(), track.tofNSigmaPr()); + // registryData.fill(HIST("hITSnsigma"), track.pt()*track.sign(), track.itsNSigmaPr()); fastjet::PseudoJet inputPseudoJet(track.px(), track.py(), track.pz(), track.energy(track.mass())); // is this fine? just TOF for invariant mass? inputPseudoJet.set_user_index(track.globalIndex()); jetInput.emplace_back(inputPseudoJet); } + if (jetInput.size()<2) return; + registryData.fill(HIST("hEventProtocol"), 1); + double ghost_maxrap = 1.0; double ghost_area = 0.005; int ghost_repeat = 1; @@ -200,17 +215,25 @@ struct AngularCorrelationsInJets { fastjet::ClusterSequenceArea clusterSeq(jetInput, jetDef, areaDef); // or CSActiveArea? jets = sorted_by_pt(clusterSeq.inclusive_jets()); if (jets.size() == 0) return; - + registryData.fill(HIST("hEventProtocol"), 2); + hardestJet = jets[0]; if(hardestJet.pt() < fMinJetPt) return; + registryData.fill(HIST("hEventProtocol"), 3); if(hardestJet.constituents().size() < 2) return; + registryData.fill(HIST("hEventProtocol"), 4); registryData.fill(HIST("hNumberOfJets"), 0); + registryData.fill(HIST("hJetRapidity"), hardestJet.rap()); constituents = hardestJet.constituents(); for (int i=0; i<(int)constituents.size(); i++) { registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); + double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); + double DeltaEta = constituents[i].eta() - hardestJet.eta(); + double Delta = TMath::Sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta); + registryData.fill(HIST("hJetConeRadius"), Delta); } fastjet::Selector selector = fastjet::SelectorAbsEtaMax(1.0) * (!fastjet::SelectorNHardest(2)); @@ -234,12 +257,13 @@ struct AngularCorrelationsInJets { for (int i=0; i<(int)constituents.size(); i++) { fastjet::PseudoJet pseudoParticle = constituents[i]; int id = pseudoParticle.user_index(); - typename TracksType::iterator jetParticle = tracks.iteratorAt(id); + typename TracksType::iterator jetParticle = tracks.iteratorAt(id); // is the global id unique enough? + double ptDiff = pseudoParticle.pt() - jetParticle.pt(); registryData.fill(HIST("hPtDiff"), ptDiff); + registryData.fill(HIST("hDCAzJetParticle"), jetParticle.dcaZ()); int particleType = 0; - registryData.fill(HIST("hDCAzJetParticle"), jetParticle.dcaZ()); if (jetParticle.pt()1) { for (int i=0; i<(int)jetProtons.size(); i++) { From 3c6ac9abf7b14f37ec7ed704c843f8d68c80640f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Thu, 6 Jun 2024 10:54:47 +0200 Subject: [PATCH 08/14] added comments with questions (this commit is only so I can rebase O2Physics) --- PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index 4087926229e..b06958a383c 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -174,7 +174,7 @@ struct AngularCorrelationsInJets { //**************************************************************************************************** template - void jetReco(const CollisionType& collision, const TracksType& tracks) { // this turns TracksType into a pointer, no? How then can we access attributes with . instead of ->? + void angCorrData(const CollisionType& collision, const TracksType& tracks) { // this turns TracksType into a pointer, no? How then can we access attributes with . instead of ->? registryData.fill(HIST("hNumberOfEvents"), 0); registryData.fill(HIST("hEventProtocol"), 0); @@ -232,11 +232,11 @@ struct AngularCorrelationsInJets { registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); double DeltaEta = constituents[i].eta() - hardestJet.eta(); - double Delta = TMath::Sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta); + double Delta = TMath::Sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta); // need 1/pT^2? registryData.fill(HIST("hJetConeRadius"), Delta); } - fastjet::Selector selector = fastjet::SelectorAbsEtaMax(1.0) * (!fastjet::SelectorNHardest(2)); + fastjet::Selector selector = fastjet::SelectorAbsEtaMax(1.0) * (!fastjet::SelectorNHardest(2)); // fix! fastjet::JetMedianBackgroundEstimator bkgEst(selector, jetDefBkg, areaDefBkg); fastjet::Subtractor subtractor(&bkgEst); subtractor.set_use_rho_m(true); @@ -461,7 +461,7 @@ struct AngularCorrelationsInJets { switch (particleType) { case 1: if (fTrackBufferProton.size() == 0) return; - for (int i=0; i<(int)fTrackBufferProton.size(); i++) { // can I do this even if the trackbuffer isn't even full yet? + for (int i=0; i<(int)fTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferProton[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferProton[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -504,11 +504,11 @@ struct AngularCorrelationsInJets { Filter prelimTrackCuts = (/* aod::track::TPCrefit == fTPCRefit && aod::track::ITSrefit == fITSRefit && */aod::track::itsChi2NCl const& tracks) + void process_ang_corr_data(aod::Collision const& collision, soa::Filtered const& tracks) { - jetReco(collision, tracks); + angCorrData(collision, tracks); } - PROCESS_SWITCH(AngularCorrelationsInJets, process_jet_reco, "reconstruct jets", true); + PROCESS_SWITCH(AngularCorrelationsInJets, process_ang_corr_data, "ang correlations in reco'ed jets", true); }; //**************************************************************************************************** From c15e64a259a980df925039c254d5708e163d99d3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lars=20J=C3=B6rgensen?= Date: Fri, 7 Jun 2024 00:14:34 +0200 Subject: [PATCH 09/14] adjusted TPC, TOF cuts, added histograms --- .../Nuspex/AngularCorrelationsInJets.cxx | 125 ++++++++++-------- 1 file changed, 71 insertions(+), 54 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index b06958a383c..5876cccac44 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -87,18 +87,18 @@ struct AngularCorrelationsInJets { // nSigma registryData.add("hTPCnsigma", "TPC n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTOFnsigma", "TOF n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - // registryData.add("hITSnsigma", "ITS n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTPCnsigmaProton", "TPC n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTOFnsigmaProton", "TOF n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - // registryData.add("hITSnsigmaProton", "ITS n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTPCnsigmaDeuteron", "TPC n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); registryData.add("hTOFnsigmaDeuteron", "TOF n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - // registryData.add("hITSnsigmaDeuteron", "ITS n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); // DCA - registryData.add("hDCAxyFullEvent", "DCA_{xy} of full event", HistType::kTH1F, {dcaxyAxis}); - registryData.add("hDCAzFullEvent", "DCA_{z} of full event", HistType::kTH1F, {dcazAxis}); - registryData.add("hDCAzJetParticle", "DCA_{z} of jet particles", HistType::kTH1F, {dcazAxis}); + registryData.add("hDCAxyFullJet", "DCA_{xy} of full jet", HistType::kTH2F, {ptAxis, dcaxyAxis}); + registryData.add("hDCAzFullJet", "DCA_{z} of full jet", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetProton", "DCA_{z} of protons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetAntiproton", "DCA_{z} of antiprotons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetDeuteron", "DCA_{z} of deuterons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetAntideuteron", "DCA_{z} of antideuterons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); // Angular Distributions registryData.add("hDeltaPhiSE", "#Delta#varphi of (anti)p, (anti)d in single event", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); @@ -112,7 +112,6 @@ struct AngularCorrelationsInJets { // Configurable cfgName{"nameOnHyperloopAndJson", value, "Flag shown on hyperloop"}; // Preliminary Cuts // Configurable fTPCRefit{"TPCRefit", 0, "Require TPC refit"}; - // Configurable fITSRefit{"ITSRefit", 0, "Require ITS refit"}; Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; Configurable fMinReqClusterITS{"minReqClusterITS", 2.0, "min number of clusters required in ITS"}; Configurable fMinRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.7f, "min ratio of crossed rows over findable clusters TPC"}; @@ -131,38 +130,38 @@ struct AngularCorrelationsInJets { // Proton Cuts Configurable fProtonDCAxy{"protonDCAxy", 0.5, "[proton] DCAxy cut"}; Configurable fProtonDCAz{"protonDCAz", 1.0, "[proton] DCAz cut"}; - Configurable fProtonITSTOFpT{"protonITSTOFswitchpT", 0.7, "[proton] pT for switch between ITS+TPC/TPC+TOF"}; - Configurable fProtonITSnsig{"protonITSnsigma", 3.0, "[proton] max ITS nsigma"}; - Configurable fProtonTPCnsigITS{"protonTPCnsigmaIfITS", 5.0, "[proton] max TPC nsigma with ITS"}; - Configurable fProtonTPCnsigTOF{"protonTPCnsigmaIfTOF", 4.0, "[proton] max TPC nsigma with TOF"}; - Configurable fProtonTOFnsig{"protonTOFnsigma", 10.0, "[proton] max TOF nsigma"}; + Configurable fProtonTPCTOFpT{"protonTPCTOFswitchpT", 0.7, "[proton] pT for switch in TPC/TOF nsigma"}; + Configurable fProtonTPCnsigLow{"protonTPCnsigmapTLow", 5.0, "[proton] max TPC nsigma with low pT"}; + Configurable fProtonTPCnsigHigh{"protonTPCnsigmapTHigh", 4.0, "[proton] max TPC nsigma with high pT"}; + Configurable fProtonTOFnsigLow{"protonTOFnsigmapTLow", 10.0, "[proton] max TOF nsigma with low pT"}; + Configurable fProtonTOFnsigHigh{"protonTOFnsigmapTHigh", 10.0, "[proton] max TOF nsigma with high pT"}; // Antiproton Cuts Configurable fAntiprotonDCAxy{"antiprotonDCAxy", 0.5, "[antiproton] DCAxy cut"}; Configurable fAntiprotonDCAz{"antiprotonDCAz", 1.0, "[antiproton] DCAz cut"}; - Configurable fAntiprotonITSTOFpT{"antiprotonITSTOFswitchpT", 0.7, "[antiproton] pT for switch between ITS+TPC/TPC+TOF"}; - Configurable fAntiprotonITSnsig{"antiprotonITSnsigma", 3.0, "[antiproton] max ITS nsigma"}; - Configurable fAntiprotonTPCnsigITS{"antiprotonTPCnsigmaIfITS", 5.0, "[antiproton] max TPC nsigma with ITS"}; - Configurable fAntiprotonTPCnsigTOF{"antiprotonTPCnsigmaIfTOF", 4.0, "[antiproton] max TPC nsigma with TOF"}; - Configurable fAntiprotonTOFnsig{"antiprotonTOFnsigma", 10.0, "[antiproton] max TOF nsigma"}; + Configurable fAntiprotonTPCTOFpT{"antiprotonTPCTOFswitchpT", 0.7, "[antiproton] pT for switch in TPC/TOF nsigma"}; + Configurable fAntiprotonTPCnsigLow{"antiprotonTPCnsigmapTLow", 5.0, "[antiproton] max TPC nsigma with low pT"}; + Configurable fAntiprotonTPCnsigHigh{"antiprotonTPCnsigmapTHigh", 4.0, "[antiproton] max TPC nsigma with high pT"}; + Configurable fAntiprotonTOFnsigLow{"antiprotonTOFnsigmapTLow", 10.0, "[antiproton] max TOF nsigma with low pT"}; + Configurable fAntiprotonTOFnsigHigh{"antiprotonTOFnsigmapTHigh", 10.0, "[antiproton] max TOF nsigma with high pT"}; // Deuteron Cuts Configurable fDeuteronDCAxy{"deuteronDCAxy", 0.5, "[deuteron] DCAxy cut"}; Configurable fDeuteronDCAz{"deuteronDCAz", 1.0, "[deuteron] DCAz cut"}; - Configurable fDeuteronITSTOFpT{"deuteronITSTOFswitchpT", 0.7, "[deuteron] pT for switch between ITS+TPC/TPC+TOF"}; - Configurable fDeuteronITSnsig{"deuteronITSnsigma", 3.0, "[deuteron] max ITS nsigma"}; - Configurable fDeuteronTPCnsigITS{"deuteronTPCnsigmaIfITS", 5.0, "[deuteron] max TPC nsigma with ITS"}; - Configurable fDeuteronTPCnsigTOF{"deuteronTPCnsigmaIfTOF", 4.0, "[deuteron] max TPC nsigma with TOF"}; - Configurable fDeuteronTOFnsig{"deuteronTOFnsigma", 10.0, "[deuteron] max TOF nsigma"}; + Configurable fDeuteronTPCTOFpT{"deuteronTPCTOFswitchpT", 0.7, "[deuteron] pT for switch in TPC/TOF nsigma"}; + Configurable fDeuteronTPCnsigLow{"deuteronTPCnsigmapTLow", 5.0, "[deuteron] max TPC nsigma with low pT"}; + Configurable fDeuteronTPCnsigHigh{"deuteronTPCnsigmapTHigh", 4.0, "[deuteron] max TPC nsigma with high pT"}; + Configurable fDeuteronTOFnsigLow{"deuteronTOFnsigmapTLow", 10.0, "[deuteron] max TOF nsigma with low pT"}; + Configurable fDeuteronTOFnsigHigh{"deuteronTOFnsigmapTHigh", 10.0, "[deuteron] max TOF nsigma with high pT"}; // Antideuteron Cuts Configurable fAntideuteronDCAxy{"antideuteronDCAxy", 0.5, "[antideuteron] DCAxy cut"}; Configurable fAntideuteronDCAz{"antideuteronDCAz", 1.0, "[antideuteron] DCAz cut"}; - Configurable fAntideuteronITSTOFpT{"antideuteronITSTOFswitchpT", 0.7, "[antideuteron] pT for switch between ITS+TPC/TPC+TOF"}; - Configurable fAntideuteronITSnsig{"antideuteronITSnsigma", 3.0, "[antideuteron] max ITS nsigma"}; - Configurable fAntideuteronTPCnsigITS{"antideuteronTPCnsigmaIfITS", 5.0, "[antideuteron] max TPC nsigma with ITS"}; - Configurable fAntideuteronTPCnsigTOF{"antideuteronTPCnsigmaIfTOF", 4.0, "[antideuteron] max TPC nsigma with TOF"}; - Configurable fAntideuteronTOFnsig{"antideuteronTOFnsigma", 10.0, "[antideuteron] max TOF nsigma"}; + Configurable fAntideuteronTPCTOFpT{"antideuteronTPCTOFswitchpT", 0.7, "[antideuteron] pT for switch in TPC/TOF nsigma"}; + Configurable fAntideuteronTPCnsigLow{"antideuteronTPCnsigmapTLow", 5.0, "[antideuteron] max TPC nsigma with low pT"}; + Configurable fAntideuteronTPCnsigHigh{"antideuteronTPCnsigmapTHigh", 4.0, "[antideuteron] max TPC nsigma with high pT"}; + Configurable fAntideuteronTOFnsigLow{"antideuteronTOFnsigmapTLow", 10.0, "[antideuteron] max TOF nsigma with low pT"}; + Configurable fAntideuteronTOFnsigHigh{"antideuteronTOFnsigmapTHigh", 10.0, "[antideuteron] max TOF nsigma with high pT"}; Configurable fTrackBufferSize{"trackBufferSize", 2000, "Number of mixed-event tracks being stored"}; @@ -191,11 +190,6 @@ struct AngularCorrelationsInJets { registryData.fill(HIST("hTrackProtocol"), 0); registryData.fill(HIST("hEtaFullEvent"), track.eta()); registryData.fill(HIST("hPtFullEvent"), track.pt()); - registryData.fill(HIST("hDCAxyFullEvent"), track.dcaXY()); - registryData.fill(HIST("hDCAzFullEvent"), track.dcaZ()); - registryData.fill(HIST("hTPCnsigma"), track.pt()*track.sign(), track.tpcNSigmaPr()); - registryData.fill(HIST("hTOFnsigma"), track.pt()*track.sign(), track.tofNSigmaPr()); - // registryData.fill(HIST("hITSnsigma"), track.pt()*track.sign(), track.itsNSigmaPr()); fastjet::PseudoJet inputPseudoJet(track.px(), track.py(), track.pz(), track.energy(track.mass())); // is this fine? just TOF for invariant mass? inputPseudoJet.set_user_index(track.globalIndex()); @@ -224,6 +218,7 @@ struct AngularCorrelationsInJets { if(hardestJet.constituents().size() < 2) return; registryData.fill(HIST("hEventProtocol"), 4); registryData.fill(HIST("hNumberOfJets"), 0); + registryData.fill(HIST("hPtTotalJet"), hardestJet.pt()); registryData.fill(HIST("hJetRapidity"), hardestJet.rap()); constituents = hardestJet.constituents(); @@ -232,7 +227,7 @@ struct AngularCorrelationsInJets { registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); double DeltaEta = constituents[i].eta() - hardestJet.eta(); - double Delta = TMath::Sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta); // need 1/pT^2? + double Delta = TMath::Sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta)/(constituents[i].pt()*constituents[i].pt()); // need 1/pT^2? registryData.fill(HIST("hJetConeRadius"), Delta); } @@ -257,18 +252,20 @@ struct AngularCorrelationsInJets { for (int i=0; i<(int)constituents.size(); i++) { fastjet::PseudoJet pseudoParticle = constituents[i]; int id = pseudoParticle.user_index(); - typename TracksType::iterator jetParticle = tracks.iteratorAt(id); // is the global id unique enough? + typename TracksType::iterator jetParticle = tracks.iteratorAt(id); + registryData.fill(HIST("hDCAxyFullJet"), jetParticle.pt()*jetParticle.sign(), jetParticle.dcaXY()); + registryData.fill(HIST("hDCAzFullJet"), jetParticle.pt()*jetParticle.sign(), jetParticle.dcaZ()); + registryData.fill(HIST("hTPCnsigma"), jetParticle.pt()*jetParticle.sign(), jetParticle.tpcNSigmaPr()); + registryData.fill(HIST("hTOFnsigma"), jetParticle.pt()*jetParticle.sign(), jetParticle.tofNSigmaPr()); double ptDiff = pseudoParticle.pt() - jetParticle.pt(); registryData.fill(HIST("hPtDiff"), ptDiff); - registryData.fill(HIST("hDCAzJetParticle"), jetParticle.dcaZ()); int particleType = 0; if (jetParticle.pt() fProtonDCAxy) return isProton; - if (TMath::Abs(track.dcaZ()) > fProtonDCAz) return isProton; + if (track.pt()fProtonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr())fProtonITSTOFpT && TMath::Abs(track.tpcNSigmaPr()) fProtonDCAxy) return false; + if (TMath::Abs(track.dcaZ()) > fProtonDCAz) return false; + + if (track.pt()fProtonTPCTOFpT && TMath::Abs(track.tofNSigmaPr()) fAntiprotonDCAxy) return isAntiproton; - if (TMath::Abs(track.dcaZ()) > fAntiprotonDCAz) return isAntiproton; + if (track.pt()fAntiprotonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr()) fAntiprotonDCAxy) return false; + if (TMath::Abs(track.dcaZ()) > fAntiprotonDCAz) return false; + + if (track.pt()fAntiprotonTPCTOFpT && TMath::Abs(track.tofNSigmaPr())fAntiprotonITSTOFpT && TMath::Abs(track.tpcNSigmaPr()) fDeuteronDCAxy) return isDeuteron; - if (TMath::Abs(track.dcaZ()) > fDeuteronDCAz) return isDeuteron; + if (track.pt()fDeuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe())fDeuteronITSTOFpT && TMath::Abs(track.tpcNSigmaPr()) fDeuteronDCAxy) return false; + if (TMath::Abs(track.dcaZ()) > fDeuteronDCAz) return false; + + if (track.pt()fDeuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) fAntideuteronDCAxy) return isAntideuteron; - if (TMath::Abs(track.dcaZ()) > fAntideuteronDCAz) return isAntideuteron; + if (track.pt()fAntideuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe()) fAntideuteronDCAxy) return false; + if (TMath::Abs(track.dcaZ()) > fAntideuteronDCAz) return false; - if (track.pt()fAntideuteronITSTOFpT && TMath::Abs(track.tpcNSigmaDe())fAntideuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) const& tracks) { From 041c8685962b89c4bf4b7efc6fb9de9424d20a9a Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 6 Jun 2024 22:19:20 +0000 Subject: [PATCH 10/14] Please consider the following formatting changes --- .../Nuspex/AngularCorrelationsInJets.cxx | 991 +++++++++--------- 1 file changed, 518 insertions(+), 473 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index 5876cccac44..b9a7116001d 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -41,485 +41,530 @@ using namespace o2::framework; using namespace o2::framework::expressions; // using SelectedCollisions = soa::Join; -using FullTracks = soa::Join; +using FullTracks = soa::Join; struct AngularCorrelationsInJets { - // HistogramRegistry registryName{"folderTitle", {}, OutputObjHandlingPolicy::AnalysisObject, , }; - HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; - // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; - - void init(InitContext&) { - - // std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; - - // AxisSpec specName = {binningInfo, "axisLabel"}; - AxisSpec ptAxis = {1000,0,100, "#it{p}_{T} [GeV/#it{c}]"}; - AxisSpec particleTypeAxis = {4,1,5, "[p, ap, d, ad]"}; - AxisSpec nsigmapTAxis = {1000,-50,50, "#it{p}_{T} [GeV/#it{c}]"}; - AxisSpec nsigmaAxis = {1000,-5,5, "n#sigma"}; - AxisSpec dcazAxis = {200,-3,3, "DCA_{z} [cm]"}; - AxisSpec dcaxyAxis = {200,-2,2, "DCA_{xy} [cm]"}; - AxisSpec angDistPhiAxis = {1000,-2,5, "#Delta#varphi"}; - AxisSpec angDistEtaAxis = {1000,-2,2, "#Delta#eta"}; - - // registryName.add("histogramName", "histogramTitle", HistType::Type, {{binningInfo}}); - - // Counters - registryData.add("hNumberOfEvents", "Number of events", HistType::kTH1I, {{1,0,1}}); - registryData.add("hNumberOfJets", "Total number of jets", HistType::kTH1I, {{1,0,1}}); - registryData.add("hEventProtocol", "Event protocol", HistType::kTH1I, {{20,0,20}}); - registryData.add("hTrackProtocol", "Track protocol", HistType::kTH1I, {{20,0,20}}); - registryData.add("hNumPartInJet", "Number of particles in a jet", HistType::kTH1I, {{200,0,200}}); - - // (Pseudo)Rapidity - registryData.add("hEtaFullEvent", "Particle pseudorapidity;#eta", HistType::kTH1F, {{200,-1,1}}); - registryData.add("hJetRapidity", "Jet rapidity;#it{y}", HistType::kTH1F, {{200,-1,1}}); - - // pT - registryData.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); - registryData.add("hPtJetParticle", "p_{T} of particles in jets", HistType::kTH1D, {ptAxis}); - registryData.add("hPtSubtractedJet", "Subtracted jet p_{T}", HistType::kTH1D, {ptAxis}); - registryData.add("hPtJetProtonDeuteron", "p_{T} of (anti)p, (anti)d", HistType::kTH2D, {particleTypeAxis, ptAxis}); - registryData.add("hPtTotalJet", "p_{T} of entire jet;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1F, {{2000,0,500}}); - registryData.add("hPtDiff", "pT difference PseudoJet/original track;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1D, {{100,-0.0000005,0.0000005}}); - - // nSigma - registryData.add("hTPCnsigma", "TPC n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - registryData.add("hTOFnsigma", "TOF n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - registryData.add("hTPCnsigmaProton", "TPC n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - registryData.add("hTOFnsigmaProton", "TOF n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - registryData.add("hTPCnsigmaDeuteron", "TPC n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - registryData.add("hTOFnsigmaDeuteron", "TOF n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); - - // DCA - registryData.add("hDCAxyFullJet", "DCA_{xy} of full jet", HistType::kTH2F, {ptAxis, dcaxyAxis}); - registryData.add("hDCAzFullJet", "DCA_{z} of full jet", HistType::kTH2F, {ptAxis, dcazAxis}); - registryData.add("hDCAzJetProton", "DCA_{z} of protons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); - registryData.add("hDCAzJetAntiproton", "DCA_{z} of antiprotons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); - registryData.add("hDCAzJetDeuteron", "DCA_{z} of deuterons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); - registryData.add("hDCAzJetAntideuteron", "DCA_{z} of antideuterons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); - - // Angular Distributions - registryData.add("hDeltaPhiSE", "#Delta#varphi of (anti)p, (anti)d in single event", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); - registryData.add("hDeltaPhiME", "#Delta#varphi of (anti)p, (anti)d in mixed events", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); - registryData.add("hDeltaPhiEtaSE", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in single event", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); - registryData.add("hDeltaPhiEtaME", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in mixed events", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); - - registryData.add("hJetConeRadius", "Jet Radius;#it{R}", HistType::kTH1F, {{100,0,1}}); - } - - // Configurable cfgName{"nameOnHyperloopAndJson", value, "Flag shown on hyperloop"}; - // Preliminary Cuts - // Configurable fTPCRefit{"TPCRefit", 0, "Require TPC refit"}; - Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; - Configurable fMinReqClusterITS{"minReqClusterITS", 2.0, "min number of clusters required in ITS"}; - Configurable fMinRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.7f, "min ratio of crossed rows over findable clusters TPC"}; - Configurable fMaxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; - Configurable fMaxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; - Configurable fMaxDCAxy{"maxDCA_xy", 0.5f, "max DCA to vertex xy"}; - Configurable fMaxDCAz{"maxDCA_z", 2.4f, "max DCA to vertex z"}; - Configurable fMaxEta{"maxEta", 0.8, "max pseudorapidity"}; - - // Jet Cuts - Configurable fJetRadius{"jetRadius", 0.4, "jet radius R"}; - Configurable fMinJetPt{"minJetPt", 10.0, "minimum total pT to accept jet"}; - Configurable fMinJetParticlePt{"minJetParticlePt", 0.0, "minimum pT to accept jet particle"}; - Configurable fMinLeadingPt{"minLeadingPt", 5.0, "minimum pT for leading track"}; - - // Proton Cuts - Configurable fProtonDCAxy{"protonDCAxy", 0.5, "[proton] DCAxy cut"}; - Configurable fProtonDCAz{"protonDCAz", 1.0, "[proton] DCAz cut"}; - Configurable fProtonTPCTOFpT{"protonTPCTOFswitchpT", 0.7, "[proton] pT for switch in TPC/TOF nsigma"}; - Configurable fProtonTPCnsigLow{"protonTPCnsigmapTLow", 5.0, "[proton] max TPC nsigma with low pT"}; - Configurable fProtonTPCnsigHigh{"protonTPCnsigmapTHigh", 4.0, "[proton] max TPC nsigma with high pT"}; - Configurable fProtonTOFnsigLow{"protonTOFnsigmapTLow", 10.0, "[proton] max TOF nsigma with low pT"}; - Configurable fProtonTOFnsigHigh{"protonTOFnsigmapTHigh", 10.0, "[proton] max TOF nsigma with high pT"}; - - // Antiproton Cuts - Configurable fAntiprotonDCAxy{"antiprotonDCAxy", 0.5, "[antiproton] DCAxy cut"}; - Configurable fAntiprotonDCAz{"antiprotonDCAz", 1.0, "[antiproton] DCAz cut"}; - Configurable fAntiprotonTPCTOFpT{"antiprotonTPCTOFswitchpT", 0.7, "[antiproton] pT for switch in TPC/TOF nsigma"}; - Configurable fAntiprotonTPCnsigLow{"antiprotonTPCnsigmapTLow", 5.0, "[antiproton] max TPC nsigma with low pT"}; - Configurable fAntiprotonTPCnsigHigh{"antiprotonTPCnsigmapTHigh", 4.0, "[antiproton] max TPC nsigma with high pT"}; - Configurable fAntiprotonTOFnsigLow{"antiprotonTOFnsigmapTLow", 10.0, "[antiproton] max TOF nsigma with low pT"}; - Configurable fAntiprotonTOFnsigHigh{"antiprotonTOFnsigmapTHigh", 10.0, "[antiproton] max TOF nsigma with high pT"}; - - // Deuteron Cuts - Configurable fDeuteronDCAxy{"deuteronDCAxy", 0.5, "[deuteron] DCAxy cut"}; - Configurable fDeuteronDCAz{"deuteronDCAz", 1.0, "[deuteron] DCAz cut"}; - Configurable fDeuteronTPCTOFpT{"deuteronTPCTOFswitchpT", 0.7, "[deuteron] pT for switch in TPC/TOF nsigma"}; - Configurable fDeuteronTPCnsigLow{"deuteronTPCnsigmapTLow", 5.0, "[deuteron] max TPC nsigma with low pT"}; - Configurable fDeuteronTPCnsigHigh{"deuteronTPCnsigmapTHigh", 4.0, "[deuteron] max TPC nsigma with high pT"}; - Configurable fDeuteronTOFnsigLow{"deuteronTOFnsigmapTLow", 10.0, "[deuteron] max TOF nsigma with low pT"}; - Configurable fDeuteronTOFnsigHigh{"deuteronTOFnsigmapTHigh", 10.0, "[deuteron] max TOF nsigma with high pT"}; - - // Antideuteron Cuts - Configurable fAntideuteronDCAxy{"antideuteronDCAxy", 0.5, "[antideuteron] DCAxy cut"}; - Configurable fAntideuteronDCAz{"antideuteronDCAz", 1.0, "[antideuteron] DCAz cut"}; - Configurable fAntideuteronTPCTOFpT{"antideuteronTPCTOFswitchpT", 0.7, "[antideuteron] pT for switch in TPC/TOF nsigma"}; - Configurable fAntideuteronTPCnsigLow{"antideuteronTPCnsigmapTLow", 5.0, "[antideuteron] max TPC nsigma with low pT"}; - Configurable fAntideuteronTPCnsigHigh{"antideuteronTPCnsigmapTHigh", 4.0, "[antideuteron] max TPC nsigma with high pT"}; - Configurable fAntideuteronTOFnsigLow{"antideuteronTOFnsigmapTLow", 10.0, "[antideuteron] max TOF nsigma with low pT"}; - Configurable fAntideuteronTOFnsigHigh{"antideuteronTOFnsigmapTHigh", 10.0, "[antideuteron] max TOF nsigma with high pT"}; - - Configurable fTrackBufferSize{"trackBufferSize", 2000, "Number of mixed-event tracks being stored"}; - - std::vector fTrackBufferProton; - std::vector fTrackBufferAntiproton; - std::vector fTrackBufferDeuteron; - std::vector fTrackBufferAntideuteron; - - //**************************************************************************************************** - - template - void angCorrData(const CollisionType& collision, const TracksType& tracks) { // this turns TracksType into a pointer, no? How then can we access attributes with . instead of ->? - registryData.fill(HIST("hNumberOfEvents"), 0); - registryData.fill(HIST("hEventProtocol"), 0); - - std::vector jetInput; - std::vector jets; - std::vector constituents; - fastjet::PseudoJet hardestJet(0.,0.,0.,0.); - fastjet::PseudoJet subtractedJet(0.,0.,0.,0.); - jetInput.clear(); - jets.clear(); - constituents.clear(); - - for (const auto& track : tracks) { - registryData.fill(HIST("hTrackProtocol"), 0); - registryData.fill(HIST("hEtaFullEvent"), track.eta()); - registryData.fill(HIST("hPtFullEvent"), track.pt()); - - fastjet::PseudoJet inputPseudoJet(track.px(), track.py(), track.pz(), track.energy(track.mass())); // is this fine? just TOF for invariant mass? - inputPseudoJet.set_user_index(track.globalIndex()); - jetInput.emplace_back(inputPseudoJet); - } - - if (jetInput.size()<2) return; - registryData.fill(HIST("hEventProtocol"), 1); - - double ghost_maxrap = 1.0; - double ghost_area = 0.005; - int ghost_repeat = 1; - fastjet::JetDefinition jetDef(fastjet::antikt_algorithm, fJetRadius); - fastjet::JetDefinition jetDefBkg(fastjet::kt_algorithm, 0.5); - fastjet::AreaDefinition areaDef(fastjet::active_area, fastjet::GhostedAreaSpec(ghost_maxrap, ghost_repeat, ghost_area)); - fastjet::AreaDefinition areaDefBkg(fastjet::active_area_explicit_ghosts, fastjet::GhostedAreaSpec(ghost_maxrap)); - fastjet::ClusterSequenceArea clusterSeq(jetInput, jetDef, areaDef); // or CSActiveArea? - jets = sorted_by_pt(clusterSeq.inclusive_jets()); - if (jets.size() == 0) return; - registryData.fill(HIST("hEventProtocol"), 2); - - hardestJet = jets[0]; - - if(hardestJet.pt() < fMinJetPt) return; - registryData.fill(HIST("hEventProtocol"), 3); - if(hardestJet.constituents().size() < 2) return; - registryData.fill(HIST("hEventProtocol"), 4); - registryData.fill(HIST("hNumberOfJets"), 0); - registryData.fill(HIST("hPtTotalJet"), hardestJet.pt()); - registryData.fill(HIST("hJetRapidity"), hardestJet.rap()); - - constituents = hardestJet.constituents(); - - for (int i=0; i<(int)constituents.size(); i++) { - registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); - double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); - double DeltaEta = constituents[i].eta() - hardestJet.eta(); - double Delta = TMath::Sqrt(DeltaPhi*DeltaPhi + DeltaEta*DeltaEta)/(constituents[i].pt()*constituents[i].pt()); // need 1/pT^2? - registryData.fill(HIST("hJetConeRadius"), Delta); - } - - fastjet::Selector selector = fastjet::SelectorAbsEtaMax(1.0) * (!fastjet::SelectorNHardest(2)); // fix! - fastjet::JetMedianBackgroundEstimator bkgEst(selector, jetDefBkg, areaDefBkg); - fastjet::Subtractor subtractor(&bkgEst); - subtractor.set_use_rho_m(true); - bkgEst.set_particles(jetInput); - - subtractedJet = subtractor(hardestJet); - if (subtractedJet.has_constituents()) { - for (int i=0; i<(int)subtractedJet.constituents().size(); i++) { - registryData.fill(HIST("hPtSubtractedJet"), subtractedJet.constituents()[i].pt()); - } - } - - std::vector jetProtons; - std::vector jetAntiprotons; - std::vector jetDeuterons; - std::vector jetAntideuterons; - - for (int i=0; i<(int)constituents.size(); i++) { - fastjet::PseudoJet pseudoParticle = constituents[i]; - int id = pseudoParticle.user_index(); - typename TracksType::iterator jetParticle = tracks.iteratorAt(id); - registryData.fill(HIST("hDCAxyFullJet"), jetParticle.pt()*jetParticle.sign(), jetParticle.dcaXY()); - registryData.fill(HIST("hDCAzFullJet"), jetParticle.pt()*jetParticle.sign(), jetParticle.dcaZ()); - registryData.fill(HIST("hTPCnsigma"), jetParticle.pt()*jetParticle.sign(), jetParticle.tpcNSigmaPr()); - registryData.fill(HIST("hTOFnsigma"), jetParticle.pt()*jetParticle.sign(), jetParticle.tofNSigmaPr()); - - double ptDiff = pseudoParticle.pt() - jetParticle.pt(); - registryData.fill(HIST("hPtDiff"), ptDiff); - int particleType = 0; - - if (jetParticle.pt()1) { - for (int i=0; i<(int)jetProtons.size(); i++) { - for (int j=i+1; j<(int)jetProtons.size(); j++) { - double DeltaPhi = TVector2::Phi_0_2pi(jetProtons[i].phi() - jetProtons[j].phi()); - double DeltaEta = TMath::Abs(jetProtons[i].eta() - jetProtons[j].eta()); - if (DeltaPhi>(1.5*TMath::Pi())) { - DeltaPhi = DeltaPhi - 2*TMath::Pi(); - } - registryData.fill(HIST("hDeltaPhiSE"), 1, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaSE"), 1, DeltaPhi, DeltaEta); - } - FillMixedEventDeltas(jetProtons[i], 1); - SetTrackBuffer(jetProtons[i], 1); - } - } - if (jetAntiprotons.size()>1) { - for (int i=0; i<(int)jetAntiprotons.size(); i++) { - for (int j=i+1; j<(int)jetAntiprotons.size(); j++) { - double DeltaPhi = TVector2::Phi_0_2pi(jetAntiprotons[i].phi() - jetAntiprotons[j].phi()); - double DeltaEta = TMath::Abs(jetAntiprotons[i].eta() - jetAntiprotons[j].eta()); - if (DeltaPhi>(1.5*TMath::Pi())) { - DeltaPhi = DeltaPhi - 2*TMath::Pi(); - } - registryData.fill(HIST("hDeltaPhiSE"), 2, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaSE"), 2, DeltaPhi, DeltaEta); - } - FillMixedEventDeltas(jetAntiprotons[i], 2); - SetTrackBuffer(jetAntiprotons[i], 2); - } - } - if (jetDeuterons.size()>1) { - for (int i=0; i<(int)jetDeuterons.size(); i++) { - for (int j=i+1; j<(int)jetDeuterons.size(); j++) { - double DeltaPhi = TVector2::Phi_0_2pi(jetDeuterons[i].phi() - jetDeuterons[j].phi()); - double DeltaEta = TMath::Abs(jetDeuterons[i].eta() - jetDeuterons[j].eta()); - if (DeltaPhi>(1.5*TMath::Pi())) { - DeltaPhi = DeltaPhi - 2*TMath::Pi(); - } - registryData.fill(HIST("hDeltaPhiSE"), 3, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaSE"), 3, DeltaPhi, DeltaEta); - } - FillMixedEventDeltas(jetDeuterons[i], 3); - SetTrackBuffer(jetDeuterons[i], 3); - } - } - if (jetAntideuterons.size()>1) { - for (int i=0; i<(int)jetAntideuterons.size(); i++) { - for (int j=i+1; j<(int)jetAntideuterons.size(); j++) { - double DeltaPhi = TVector2::Phi_0_2pi(jetAntideuterons[i].phi() - jetAntideuterons[j].phi()); - double DeltaEta = TMath::Abs(jetAntideuterons[i].eta() - jetAntideuterons[j].eta()); - if (DeltaPhi>(1.5*TMath::Pi())) { - DeltaPhi = DeltaPhi - 2*TMath::Pi(); - } - registryData.fill(HIST("hDeltaPhiSE"), 4, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaSE"), 4, DeltaPhi, DeltaEta); - } - FillMixedEventDeltas(jetAntideuterons[i], 4); - SetTrackBuffer(jetAntideuterons[i], 4); - } - } - } - - template - bool IsProton(const T1& track) { - bool isProton = false; - if (track.sign()<0) return isProton; - - if (track.pt()fProtonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr()) fProtonDCAxy) return false; - if (TMath::Abs(track.dcaZ()) > fProtonDCAz) return false; - - if (track.pt()fProtonTPCTOFpT && TMath::Abs(track.tofNSigmaPr()) - bool IsAntiproton(const T2& track) { - bool isAntiproton = false; - if (track.sign()<0) return isAntiproton; - - if (track.pt()fAntiprotonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr()) fAntiprotonDCAxy) return false; - if (TMath::Abs(track.dcaZ()) > fAntiprotonDCAz) return false; - - if (track.pt()fAntiprotonTPCTOFpT && TMath::Abs(track.tofNSigmaPr()) - bool IsDeuteron(const T3& track) { - bool isDeuteron = false; - if (track.sign()<0) return isDeuteron; - - if (track.pt()fDeuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe()) fDeuteronDCAxy) return false; - if (TMath::Abs(track.dcaZ()) > fDeuteronDCAz) return false; - - if (track.pt()fDeuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) - bool IsAntideuteron(const T4& track) { - bool isAntideuteron = false; - if (track.sign()<0) return isAntideuteron; - - if (track.pt()fAntideuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe()) fAntideuteronDCAxy) return false; - if (TMath::Abs(track.dcaZ()) > fAntideuteronDCAz) return false; - - if (track.pt()fAntideuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) - void SetTrackBuffer(const T5& track, int particleType) { - switch (particleType) { - case 1: - if ((int)fTrackBufferProton.size()==fTrackBufferSize) { - fTrackBufferProton.insert(fTrackBufferProton.begin(), track); - fTrackBufferProton.resize(fTrackBufferSize); - } else if ((int)fTrackBufferProton.size() - void FillMixedEventDeltas(const T6& track, int particleType) { - switch (particleType) { - case 1: - if (fTrackBufferProton.size() == 0) return; - for (int i=0; i<(int)fTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? - double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferProton[i].phi()); - double DeltaEta = TMath::Abs(track.eta() - fTrackBufferProton[i].eta()); - registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); - } - break; - case 2: - if (fTrackBufferAntiproton.size() == 0) return; - for (int i=0; i<(int)fTrackBufferAntiproton.size(); i++) { - double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntiproton[i].phi()); - double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntiproton[i].eta()); - registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); - } - break; - case 3: - if (fTrackBufferDeuteron.size() == 0) return; - for (int i=0; i<(int)fTrackBufferDeuteron.size(); i++) { - double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferDeuteron[i].phi()); - double DeltaEta = TMath::Abs(track.eta() - fTrackBufferDeuteron[i].eta()); - registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); - } - break; - case 4: - if (fTrackBufferAntideuteron.size() == 0) return; - for (int i=0; i<(int)fTrackBufferAntideuteron.size(); i++) { - double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntideuteron[i].phi()); - double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntideuteron[i].eta()); - registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); - registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); - } - break; - default: - LOG(warn) << "FillMixedEventDeltas: invalid particle ID!"; - } - } + // HistogramRegistry registryName{"folderTitle", {}, OutputObjHandlingPolicy::AnalysisObject, , }; + HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; + // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; + + void init(InitContext&) + { + + // std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; + + // AxisSpec specName = {binningInfo, "axisLabel"}; + AxisSpec ptAxis = {1000, 0, 100, "#it{p}_{T} [GeV/#it{c}]"}; + AxisSpec particleTypeAxis = {4, 1, 5, "[p, ap, d, ad]"}; + AxisSpec nsigmapTAxis = {1000, -50, 50, "#it{p}_{T} [GeV/#it{c}]"}; + AxisSpec nsigmaAxis = {1000, -5, 5, "n#sigma"}; + AxisSpec dcazAxis = {200, -3, 3, "DCA_{z} [cm]"}; + AxisSpec dcaxyAxis = {200, -2, 2, "DCA_{xy} [cm]"}; + AxisSpec angDistPhiAxis = {1000, -2, 5, "#Delta#varphi"}; + AxisSpec angDistEtaAxis = {1000, -2, 2, "#Delta#eta"}; + + // registryName.add("histogramName", "histogramTitle", HistType::Type, {{binningInfo}}); + + // Counters + registryData.add("hNumberOfEvents", "Number of events", HistType::kTH1I, {{1, 0, 1}}); + registryData.add("hNumberOfJets", "Total number of jets", HistType::kTH1I, {{1, 0, 1}}); + registryData.add("hEventProtocol", "Event protocol", HistType::kTH1I, {{20, 0, 20}}); + registryData.add("hTrackProtocol", "Track protocol", HistType::kTH1I, {{20, 0, 20}}); + registryData.add("hNumPartInJet", "Number of particles in a jet", HistType::kTH1I, {{200, 0, 200}}); + + // (Pseudo)Rapidity + registryData.add("hEtaFullEvent", "Particle pseudorapidity;#eta", HistType::kTH1F, {{200, -1, 1}}); + registryData.add("hJetRapidity", "Jet rapidity;#it{y}", HistType::kTH1F, {{200, -1, 1}}); + + // pT + registryData.add("hPtFullEvent", "p_{T} after basic cuts", HistType::kTH1F, {ptAxis}); + registryData.add("hPtJetParticle", "p_{T} of particles in jets", HistType::kTH1D, {ptAxis}); + registryData.add("hPtSubtractedJet", "Subtracted jet p_{T}", HistType::kTH1D, {ptAxis}); + registryData.add("hPtJetProtonDeuteron", "p_{T} of (anti)p, (anti)d", HistType::kTH2D, {particleTypeAxis, ptAxis}); + registryData.add("hPtTotalJet", "p_{T} of entire jet;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1F, {{2000, 0, 500}}); + registryData.add("hPtDiff", "pT difference PseudoJet/original track;#it{p}_{T} [GeV/#it{c}]", HistType::kTH1D, {{100, -0.0000005, 0.0000005}}); + + // nSigma + registryData.add("hTPCnsigma", "TPC n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTOFnsigma", "TOF n#sigma for full event", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTPCnsigmaProton", "TPC n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTOFnsigmaProton", "TOF n#sigma for (anti)proton", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTPCnsigmaDeuteron", "TPC n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + registryData.add("hTOFnsigmaDeuteron", "TOF n#sigma for (anti)deuteron", HistType::kTH2F, {nsigmapTAxis, nsigmaAxis}); + + // DCA + registryData.add("hDCAxyFullJet", "DCA_{xy} of full jet", HistType::kTH2F, {ptAxis, dcaxyAxis}); + registryData.add("hDCAzFullJet", "DCA_{z} of full jet", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetProton", "DCA_{z} of protons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetAntiproton", "DCA_{z} of antiprotons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetDeuteron", "DCA_{z} of deuterons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); + registryData.add("hDCAzJetAntideuteron", "DCA_{z} of antideuterons after TPC cut", HistType::kTH2F, {ptAxis, dcazAxis}); + + // Angular Distributions + registryData.add("hDeltaPhiSE", "#Delta#varphi of (anti)p, (anti)d in single event", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); + registryData.add("hDeltaPhiME", "#Delta#varphi of (anti)p, (anti)d in mixed events", HistType::kTH2D, {particleTypeAxis, angDistPhiAxis}); + registryData.add("hDeltaPhiEtaSE", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in single event", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); + registryData.add("hDeltaPhiEtaME", "#Delta#varphi vs #Delta#eta of (anti)p, (anti)d in mixed events", HistType::kTH3D, {particleTypeAxis, angDistPhiAxis, angDistEtaAxis}); + + registryData.add("hJetConeRadius", "Jet Radius;#it{R}", HistType::kTH1F, {{100, 0, 1}}); + } + + // Configurable cfgName{"nameOnHyperloopAndJson", value, "Flag shown on hyperloop"}; + // Preliminary Cuts + // Configurable fTPCRefit{"TPCRefit", 0, "Require TPC refit"}; + Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; + Configurable fMinReqClusterITS{"minReqClusterITS", 2.0, "min number of clusters required in ITS"}; + Configurable fMinRatioCrossedRowsTPC{"minRatioCrossedRowsTPC", 0.7f, "min ratio of crossed rows over findable clusters TPC"}; + Configurable fMaxChi2ITS{"maxChi2ITS", 36.0f, "max chi2 per cluster ITS"}; + Configurable fMaxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; + Configurable fMaxDCAxy{"maxDCA_xy", 0.5f, "max DCA to vertex xy"}; + Configurable fMaxDCAz{"maxDCA_z", 2.4f, "max DCA to vertex z"}; + Configurable fMaxEta{"maxEta", 0.8, "max pseudorapidity"}; + + // Jet Cuts + Configurable fJetRadius{"jetRadius", 0.4, "jet radius R"}; + Configurable fMinJetPt{"minJetPt", 10.0, "minimum total pT to accept jet"}; + Configurable fMinJetParticlePt{"minJetParticlePt", 0.0, "minimum pT to accept jet particle"}; + Configurable fMinLeadingPt{"minLeadingPt", 5.0, "minimum pT for leading track"}; + + // Proton Cuts + Configurable fProtonDCAxy{"protonDCAxy", 0.5, "[proton] DCAxy cut"}; + Configurable fProtonDCAz{"protonDCAz", 1.0, "[proton] DCAz cut"}; + Configurable fProtonTPCTOFpT{"protonTPCTOFswitchpT", 0.7, "[proton] pT for switch in TPC/TOF nsigma"}; + Configurable fProtonTPCnsigLow{"protonTPCnsigmapTLow", 5.0, "[proton] max TPC nsigma with low pT"}; + Configurable fProtonTPCnsigHigh{"protonTPCnsigmapTHigh", 4.0, "[proton] max TPC nsigma with high pT"}; + Configurable fProtonTOFnsigLow{"protonTOFnsigmapTLow", 10.0, "[proton] max TOF nsigma with low pT"}; + Configurable fProtonTOFnsigHigh{"protonTOFnsigmapTHigh", 10.0, "[proton] max TOF nsigma with high pT"}; + + // Antiproton Cuts + Configurable fAntiprotonDCAxy{"antiprotonDCAxy", 0.5, "[antiproton] DCAxy cut"}; + Configurable fAntiprotonDCAz{"antiprotonDCAz", 1.0, "[antiproton] DCAz cut"}; + Configurable fAntiprotonTPCTOFpT{"antiprotonTPCTOFswitchpT", 0.7, "[antiproton] pT for switch in TPC/TOF nsigma"}; + Configurable fAntiprotonTPCnsigLow{"antiprotonTPCnsigmapTLow", 5.0, "[antiproton] max TPC nsigma with low pT"}; + Configurable fAntiprotonTPCnsigHigh{"antiprotonTPCnsigmapTHigh", 4.0, "[antiproton] max TPC nsigma with high pT"}; + Configurable fAntiprotonTOFnsigLow{"antiprotonTOFnsigmapTLow", 10.0, "[antiproton] max TOF nsigma with low pT"}; + Configurable fAntiprotonTOFnsigHigh{"antiprotonTOFnsigmapTHigh", 10.0, "[antiproton] max TOF nsigma with high pT"}; + + // Deuteron Cuts + Configurable fDeuteronDCAxy{"deuteronDCAxy", 0.5, "[deuteron] DCAxy cut"}; + Configurable fDeuteronDCAz{"deuteronDCAz", 1.0, "[deuteron] DCAz cut"}; + Configurable fDeuteronTPCTOFpT{"deuteronTPCTOFswitchpT", 0.7, "[deuteron] pT for switch in TPC/TOF nsigma"}; + Configurable fDeuteronTPCnsigLow{"deuteronTPCnsigmapTLow", 5.0, "[deuteron] max TPC nsigma with low pT"}; + Configurable fDeuteronTPCnsigHigh{"deuteronTPCnsigmapTHigh", 4.0, "[deuteron] max TPC nsigma with high pT"}; + Configurable fDeuteronTOFnsigLow{"deuteronTOFnsigmapTLow", 10.0, "[deuteron] max TOF nsigma with low pT"}; + Configurable fDeuteronTOFnsigHigh{"deuteronTOFnsigmapTHigh", 10.0, "[deuteron] max TOF nsigma with high pT"}; + + // Antideuteron Cuts + Configurable fAntideuteronDCAxy{"antideuteronDCAxy", 0.5, "[antideuteron] DCAxy cut"}; + Configurable fAntideuteronDCAz{"antideuteronDCAz", 1.0, "[antideuteron] DCAz cut"}; + Configurable fAntideuteronTPCTOFpT{"antideuteronTPCTOFswitchpT", 0.7, "[antideuteron] pT for switch in TPC/TOF nsigma"}; + Configurable fAntideuteronTPCnsigLow{"antideuteronTPCnsigmapTLow", 5.0, "[antideuteron] max TPC nsigma with low pT"}; + Configurable fAntideuteronTPCnsigHigh{"antideuteronTPCnsigmapTHigh", 4.0, "[antideuteron] max TPC nsigma with high pT"}; + Configurable fAntideuteronTOFnsigLow{"antideuteronTOFnsigmapTLow", 10.0, "[antideuteron] max TOF nsigma with low pT"}; + Configurable fAntideuteronTOFnsigHigh{"antideuteronTOFnsigmapTHigh", 10.0, "[antideuteron] max TOF nsigma with high pT"}; + + Configurable fTrackBufferSize{"trackBufferSize", 2000, "Number of mixed-event tracks being stored"}; + + std::vector fTrackBufferProton; + std::vector fTrackBufferAntiproton; + std::vector fTrackBufferDeuteron; + std::vector fTrackBufferAntideuteron; + + //**************************************************************************************************** + + template + void angCorrData(const CollisionType& collision, const TracksType& tracks) + { // this turns TracksType into a pointer, no? How then can we access attributes with . instead of ->? + registryData.fill(HIST("hNumberOfEvents"), 0); + registryData.fill(HIST("hEventProtocol"), 0); + + std::vector jetInput; + std::vector jets; + std::vector constituents; + fastjet::PseudoJet hardestJet(0., 0., 0., 0.); + fastjet::PseudoJet subtractedJet(0., 0., 0., 0.); + jetInput.clear(); + jets.clear(); + constituents.clear(); + + for (const auto& track : tracks) { + registryData.fill(HIST("hTrackProtocol"), 0); + registryData.fill(HIST("hEtaFullEvent"), track.eta()); + registryData.fill(HIST("hPtFullEvent"), track.pt()); + + fastjet::PseudoJet inputPseudoJet(track.px(), track.py(), track.pz(), track.energy(track.mass())); // is this fine? just TOF for invariant mass? + inputPseudoJet.set_user_index(track.globalIndex()); + jetInput.emplace_back(inputPseudoJet); + } + + if (jetInput.size() < 2) + return; + registryData.fill(HIST("hEventProtocol"), 1); + + double ghost_maxrap = 1.0; + double ghost_area = 0.005; + int ghost_repeat = 1; + fastjet::JetDefinition jetDef(fastjet::antikt_algorithm, fJetRadius); + fastjet::JetDefinition jetDefBkg(fastjet::kt_algorithm, 0.5); + fastjet::AreaDefinition areaDef(fastjet::active_area, fastjet::GhostedAreaSpec(ghost_maxrap, ghost_repeat, ghost_area)); + fastjet::AreaDefinition areaDefBkg(fastjet::active_area_explicit_ghosts, fastjet::GhostedAreaSpec(ghost_maxrap)); + fastjet::ClusterSequenceArea clusterSeq(jetInput, jetDef, areaDef); // or CSActiveArea? + jets = sorted_by_pt(clusterSeq.inclusive_jets()); + if (jets.size() == 0) + return; + registryData.fill(HIST("hEventProtocol"), 2); + + hardestJet = jets[0]; + + if (hardestJet.pt() < fMinJetPt) + return; + registryData.fill(HIST("hEventProtocol"), 3); + if (hardestJet.constituents().size() < 2) + return; + registryData.fill(HIST("hEventProtocol"), 4); + registryData.fill(HIST("hNumberOfJets"), 0); + registryData.fill(HIST("hPtTotalJet"), hardestJet.pt()); + registryData.fill(HIST("hJetRapidity"), hardestJet.rap()); + + constituents = hardestJet.constituents(); + + for (int i = 0; i < (int)constituents.size(); i++) { + registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); + double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); + double DeltaEta = constituents[i].eta() - hardestJet.eta(); + double Delta = TMath::Sqrt(DeltaPhi * DeltaPhi + DeltaEta * DeltaEta) / (constituents[i].pt() * constituents[i].pt()); // need 1/pT^2? + registryData.fill(HIST("hJetConeRadius"), Delta); + } + + fastjet::Selector selector = fastjet::SelectorAbsEtaMax(1.0) * (!fastjet::SelectorNHardest(2)); // fix! + fastjet::JetMedianBackgroundEstimator bkgEst(selector, jetDefBkg, areaDefBkg); + fastjet::Subtractor subtractor(&bkgEst); + subtractor.set_use_rho_m(true); + bkgEst.set_particles(jetInput); + + subtractedJet = subtractor(hardestJet); + if (subtractedJet.has_constituents()) { + for (int i = 0; i < (int)subtractedJet.constituents().size(); i++) { + registryData.fill(HIST("hPtSubtractedJet"), subtractedJet.constituents()[i].pt()); + } + } + + std::vector jetProtons; + std::vector jetAntiprotons; + std::vector jetDeuterons; + std::vector jetAntideuterons; + + for (int i = 0; i < (int)constituents.size(); i++) { + fastjet::PseudoJet pseudoParticle = constituents[i]; + int id = pseudoParticle.user_index(); + typename TracksType::iterator jetParticle = tracks.iteratorAt(id); + registryData.fill(HIST("hDCAxyFullJet"), jetParticle.pt() * jetParticle.sign(), jetParticle.dcaXY()); + registryData.fill(HIST("hDCAzFullJet"), jetParticle.pt() * jetParticle.sign(), jetParticle.dcaZ()); + registryData.fill(HIST("hTPCnsigma"), jetParticle.pt() * jetParticle.sign(), jetParticle.tpcNSigmaPr()); + registryData.fill(HIST("hTOFnsigma"), jetParticle.pt() * jetParticle.sign(), jetParticle.tofNSigmaPr()); + + double ptDiff = pseudoParticle.pt() - jetParticle.pt(); + registryData.fill(HIST("hPtDiff"), ptDiff); + int particleType = 0; + + if (jetParticle.pt() < fMinJetParticlePt) + continue; + if (IsProton(jetParticle) || IsAntiproton(jetParticle)) { // collect (anti)protons in jet + registryData.fill(HIST("hTPCnsigmaProton"), jetParticle.pt() * jetParticle.sign(), jetParticle.tpcNSigmaPr()); + registryData.fill(HIST("hTOFnsigmaProton"), jetParticle.pt() * jetParticle.sign(), jetParticle.tofNSigmaPr()); + if (IsProton(jetParticle)) { + particleType = 1; + registryData.fill(HIST("hTrackProtocol"), 6); // # protons + jetProtons.emplace_back(jetParticle); + } else { + particleType = 2; + registryData.fill(HIST("hTrackProtocol"), 7); // # antiprotons + jetAntiprotons.emplace_back(jetParticle); + } + } else if (IsDeuteron(jetParticle) || IsAntideuteron(jetParticle)) { // collect (anti)deuterons in jet + registryData.fill(HIST("hTPCnsigmaDeuteron"), jetParticle.pt() * jetParticle.sign(), jetParticle.tpcNSigmaDe()); + registryData.fill(HIST("hTOFnsigmaDeuteron"), jetParticle.pt() * jetParticle.sign(), jetParticle.tofNSigmaDe()); + if (IsDeuteron(jetParticle)) { + particleType = 3; + registryData.fill(HIST("hTrackProtocol"), 8); // # deuterons + jetDeuterons.emplace_back(jetParticle); + } else { + particleType = 4; + registryData.fill(HIST("hTrackProtocol"), 9); // # antideuterons + jetAntideuterons.emplace_back(jetParticle); + } + } + registryData.fill(HIST("hPtJetProtonDeuteron"), particleType, jetParticle.pt()); + } // for (int i=0; i<(int)constituents.size(); i++) + + if ((jetProtons.size() < 2) && (jetAntiprotons.size() < 2) && (jetDeuterons.size() < 2) && (jetAntideuterons.size() < 2)) + return; + registryData.fill(HIST("hEventProtocol"), 5); + + if (jetProtons.size() > 1) { + for (int i = 0; i < (int)jetProtons.size(); i++) { + for (int j = i + 1; j < (int)jetProtons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetProtons[i].phi() - jetProtons[j].phi()); + double DeltaEta = TMath::Abs(jetProtons[i].eta() - jetProtons[j].eta()); + if (DeltaPhi > (1.5 * TMath::Pi())) { + DeltaPhi = DeltaPhi - 2 * TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 1, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 1, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetProtons[i], 1); + SetTrackBuffer(jetProtons[i], 1); + } + } + if (jetAntiprotons.size() > 1) { + for (int i = 0; i < (int)jetAntiprotons.size(); i++) { + for (int j = i + 1; j < (int)jetAntiprotons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetAntiprotons[i].phi() - jetAntiprotons[j].phi()); + double DeltaEta = TMath::Abs(jetAntiprotons[i].eta() - jetAntiprotons[j].eta()); + if (DeltaPhi > (1.5 * TMath::Pi())) { + DeltaPhi = DeltaPhi - 2 * TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 2, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 2, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetAntiprotons[i], 2); + SetTrackBuffer(jetAntiprotons[i], 2); + } + } + if (jetDeuterons.size() > 1) { + for (int i = 0; i < (int)jetDeuterons.size(); i++) { + for (int j = i + 1; j < (int)jetDeuterons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetDeuterons[i].phi() - jetDeuterons[j].phi()); + double DeltaEta = TMath::Abs(jetDeuterons[i].eta() - jetDeuterons[j].eta()); + if (DeltaPhi > (1.5 * TMath::Pi())) { + DeltaPhi = DeltaPhi - 2 * TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 3, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 3, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetDeuterons[i], 3); + SetTrackBuffer(jetDeuterons[i], 3); + } + } + if (jetAntideuterons.size() > 1) { + for (int i = 0; i < (int)jetAntideuterons.size(); i++) { + for (int j = i + 1; j < (int)jetAntideuterons.size(); j++) { + double DeltaPhi = TVector2::Phi_0_2pi(jetAntideuterons[i].phi() - jetAntideuterons[j].phi()); + double DeltaEta = TMath::Abs(jetAntideuterons[i].eta() - jetAntideuterons[j].eta()); + if (DeltaPhi > (1.5 * TMath::Pi())) { + DeltaPhi = DeltaPhi - 2 * TMath::Pi(); + } + registryData.fill(HIST("hDeltaPhiSE"), 4, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaSE"), 4, DeltaPhi, DeltaEta); + } + FillMixedEventDeltas(jetAntideuterons[i], 4); + SetTrackBuffer(jetAntideuterons[i], 4); + } + } + } + + template + bool IsProton(const T1& track) + { + bool isProton = false; + if (track.sign() < 0) + return isProton; + + if (track.pt() < fProtonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr()) < fProtonTPCnsigLow) + isProton = true; + if (track.pt() > fProtonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr()) < fProtonTPCnsigHigh) + isProton = true; + + registryData.fill(HIST("hDCAzJetProton"), track.pt() * track.sign(), track.dcaZ()); + + if (TMath::Abs(track.dcaXY()) > fProtonDCAxy) + return false; + if (TMath::Abs(track.dcaZ()) > fProtonDCAz) + return false; + + if (track.pt() < fProtonTPCTOFpT && TMath::Abs(track.tofNSigmaPr()) < fProtonTOFnsigLow) + isProton = true; + if (track.pt() > fProtonTPCTOFpT && TMath::Abs(track.tofNSigmaPr()) < fProtonTOFnsigHigh) + isProton = true; + + return isProton; + } + + template + bool IsAntiproton(const T2& track) + { + bool isAntiproton = false; + if (track.sign() < 0) + return isAntiproton; + + if (track.pt() < fAntiprotonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr()) < fAntiprotonTPCnsigLow) + isAntiproton = true; + if (track.pt() > fAntiprotonTPCTOFpT && TMath::Abs(track.tpcNSigmaPr()) < fAntiprotonTPCnsigHigh) + isAntiproton = true; + + registryData.fill(HIST("hDCAzJetAntiproton"), track.pt() * track.sign(), track.dcaZ()); + + if (TMath::Abs(track.dcaXY()) > fAntiprotonDCAxy) + return false; + if (TMath::Abs(track.dcaZ()) > fAntiprotonDCAz) + return false; + + if (track.pt() < fAntiprotonTPCTOFpT && TMath::Abs(track.tofNSigmaPr()) < fAntiprotonTOFnsigLow) + isAntiproton = true; + if (track.pt() > fAntiprotonTPCTOFpT && TMath::Abs(track.tofNSigmaPr()) < fAntiprotonTOFnsigHigh) + isAntiproton = true; + + return isAntiproton; + } + + template + bool IsDeuteron(const T3& track) + { + bool isDeuteron = false; + if (track.sign() < 0) + return isDeuteron; + + if (track.pt() < fDeuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe()) < fDeuteronTPCnsigLow) + isDeuteron = true; + if (track.pt() > fDeuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe()) < fDeuteronTPCnsigHigh) + isDeuteron = true; + + registryData.fill(HIST("hDCAzJetDeuteron"), track.pt() * track.sign(), track.dcaZ()); + + if (TMath::Abs(track.dcaXY()) > fDeuteronDCAxy) + return false; + if (TMath::Abs(track.dcaZ()) > fDeuteronDCAz) + return false; + + if (track.pt() < fDeuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) < fDeuteronTOFnsigLow) + isDeuteron = true; + if (track.pt() > fDeuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) < fDeuteronTOFnsigHigh) + isDeuteron = true; + + return isDeuteron; + } + + template + bool IsAntideuteron(const T4& track) + { + bool isAntideuteron = false; + if (track.sign() < 0) + return isAntideuteron; + + if (track.pt() < fAntideuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe()) < fAntideuteronTPCnsigLow) + isAntideuteron = true; + if (track.pt() > fAntideuteronTPCTOFpT && TMath::Abs(track.tpcNSigmaDe()) < fAntideuteronTPCnsigHigh) + isAntideuteron = true; + + registryData.fill(HIST("hDCAzJetAntideuteron"), track.pt() * track.sign(), track.dcaZ()); + + if (TMath::Abs(track.dcaXY()) > fAntideuteronDCAxy) + return false; + if (TMath::Abs(track.dcaZ()) > fAntideuteronDCAz) + return false; + + if (track.pt() < fAntideuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) < fAntideuteronTOFnsigLow) + isAntideuteron = true; + if (track.pt() > fAntideuteronTPCTOFpT && TMath::Abs(track.tofNSigmaDe()) < fAntideuteronTOFnsigHigh) + isAntideuteron = true; + + return isAntideuteron; + } + + template + void SetTrackBuffer(const T5& track, int particleType) + { + switch (particleType) { + case 1: + if ((int)fTrackBufferProton.size() == fTrackBufferSize) { + fTrackBufferProton.insert(fTrackBufferProton.begin(), track); + fTrackBufferProton.resize(fTrackBufferSize); + } else if ((int)fTrackBufferProton.size() < fTrackBufferSize) { + fTrackBufferProton.emplace_back(track); + } + break; + case 2: + if ((int)fTrackBufferAntiproton.size() == fTrackBufferSize) { + fTrackBufferAntiproton.insert(fTrackBufferAntiproton.begin(), track); + fTrackBufferAntiproton.resize(fTrackBufferSize); + } else if ((int)fTrackBufferAntiproton.size() < fTrackBufferSize) { + fTrackBufferAntiproton.emplace_back(track); + } + break; + case 3: + if ((int)fTrackBufferDeuteron.size() == fTrackBufferSize) { + fTrackBufferDeuteron.insert(fTrackBufferDeuteron.begin(), track); + fTrackBufferDeuteron.resize(fTrackBufferSize); + } else if ((int)fTrackBufferDeuteron.size() < fTrackBufferSize) { + fTrackBufferDeuteron.emplace_back(track); + } + break; + case 4: + if ((int)fTrackBufferAntideuteron.size() == fTrackBufferSize) { + fTrackBufferAntideuteron.insert(fTrackBufferAntideuteron.begin(), track); + fTrackBufferAntideuteron.resize(fTrackBufferSize); + } else if ((int)fTrackBufferAntideuteron.size() < fTrackBufferSize) { + fTrackBufferAntideuteron.emplace_back(track); + } + break; + default: + LOG(warn) << "SetTrackBuffer: invalid particle ID!"; + } + } + + template + void FillMixedEventDeltas(const T6& track, int particleType) + { + switch (particleType) { + case 1: + if (fTrackBufferProton.size() == 0) + return; + for (int i = 0; i < (int)fTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferProton[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferProton[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + case 2: + if (fTrackBufferAntiproton.size() == 0) + return; + for (int i = 0; i < (int)fTrackBufferAntiproton.size(); i++) { + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntiproton[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntiproton[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + case 3: + if (fTrackBufferDeuteron.size() == 0) + return; + for (int i = 0; i < (int)fTrackBufferDeuteron.size(); i++) { + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferDeuteron[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferDeuteron[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + case 4: + if (fTrackBufferAntideuteron.size() == 0) + return; + for (int i = 0; i < (int)fTrackBufferAntideuteron.size(); i++) { + double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntideuteron[i].phi()); + double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntideuteron[i].eta()); + registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); + registryData.fill(HIST("hDeltaPhiEtaME"), particleType, DeltaPhi, DeltaEta); + } + break; + default: + LOG(warn) << "FillMixedEventDeltas: invalid particle ID!"; + } + } //**************************************************************************************************** - Filter prelimTrackCuts = (/* aod::track::TPCrefit == fTPCRefit && */aod::track::itsChi2NCl const& tracks) { From a8523923fa0fe0d8c206201b244bcb1db937cec6 Mon Sep 17 00:00:00 2001 From: Lars <146946151+ljoergen@users.noreply.github.com> Date: Fri, 7 Jun 2024 10:38:20 +0200 Subject: [PATCH 11/14] Updated casts in AngularCorrelationsInJets.cxx --- .../Nuspex/AngularCorrelationsInJets.cxx | 56 ++++++++----------- 1 file changed, 24 insertions(+), 32 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index b9a7116001d..51d1de3a08a 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -45,15 +45,10 @@ using FullTracks = soa::Join, }; HistogramRegistry registryData{"jetOutput", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; - // OutputObj histogramName{Type("histogramName", "histogramTitle;Axis", nbins,minbin,maxbin)}; void init(InitContext&) { - - // std::vector ptBinning = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.8, 2.0, 2.2, 2.4, 2.8, 3.2, 3.6, 4., 5., 6., 8., 10., 12., 14.}; - // AxisSpec specName = {binningInfo, "axisLabel"}; AxisSpec ptAxis = {1000, 0, 100, "#it{p}_{T} [GeV/#it{c}]"}; AxisSpec particleTypeAxis = {4, 1, 5, "[p, ap, d, ad]"}; @@ -64,8 +59,6 @@ struct AngularCorrelationsInJets { AxisSpec angDistPhiAxis = {1000, -2, 5, "#Delta#varphi"}; AxisSpec angDistEtaAxis = {1000, -2, 2, "#Delta#eta"}; - // registryName.add("histogramName", "histogramTitle", HistType::Type, {{binningInfo}}); - // Counters registryData.add("hNumberOfEvents", "Number of events", HistType::kTH1I, {{1, 0, 1}}); registryData.add("hNumberOfJets", "Total number of jets", HistType::kTH1I, {{1, 0, 1}}); @@ -110,7 +103,6 @@ struct AngularCorrelationsInJets { registryData.add("hJetConeRadius", "Jet Radius;#it{R}", HistType::kTH1F, {{100, 0, 1}}); } - // Configurable cfgName{"nameOnHyperloopAndJson", value, "Flag shown on hyperloop"}; // Preliminary Cuts // Configurable fTPCRefit{"TPCRefit", 0, "Require TPC refit"}; Configurable fMinNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of crossed rows TPC"}; @@ -175,7 +167,7 @@ struct AngularCorrelationsInJets { template void angCorrData(const CollisionType& collision, const TracksType& tracks) - { // this turns TracksType into a pointer, no? How then can we access attributes with . instead of ->? + { registryData.fill(HIST("hNumberOfEvents"), 0); registryData.fill(HIST("hEventProtocol"), 0); @@ -229,7 +221,7 @@ struct AngularCorrelationsInJets { constituents = hardestJet.constituents(); - for (int i = 0; i < (int)constituents.size(); i++) { + for (int i = 0; i < static_castconstituents.size(); i++) { registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); double DeltaEta = constituents[i].eta() - hardestJet.eta(); @@ -245,7 +237,7 @@ struct AngularCorrelationsInJets { subtractedJet = subtractor(hardestJet); if (subtractedJet.has_constituents()) { - for (int i = 0; i < (int)subtractedJet.constituents().size(); i++) { + for (int i = 0; i < static_castsubtractedJet.constituents().size(); i++) { registryData.fill(HIST("hPtSubtractedJet"), subtractedJet.constituents()[i].pt()); } } @@ -255,7 +247,7 @@ struct AngularCorrelationsInJets { std::vector jetDeuterons; std::vector jetAntideuterons; - for (int i = 0; i < (int)constituents.size(); i++) { + for (int i = 0; i < static_castconstituents.size(); i++) { fastjet::PseudoJet pseudoParticle = constituents[i]; int id = pseudoParticle.user_index(); typename TracksType::iterator jetParticle = tracks.iteratorAt(id); @@ -303,8 +295,8 @@ struct AngularCorrelationsInJets { registryData.fill(HIST("hEventProtocol"), 5); if (jetProtons.size() > 1) { - for (int i = 0; i < (int)jetProtons.size(); i++) { - for (int j = i + 1; j < (int)jetProtons.size(); j++) { + for (int i = 0; i < static_castjetProtons.size(); i++) { + for (int j = i + 1; j < static_castjetProtons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetProtons[i].phi() - jetProtons[j].phi()); double DeltaEta = TMath::Abs(jetProtons[i].eta() - jetProtons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -318,8 +310,8 @@ struct AngularCorrelationsInJets { } } if (jetAntiprotons.size() > 1) { - for (int i = 0; i < (int)jetAntiprotons.size(); i++) { - for (int j = i + 1; j < (int)jetAntiprotons.size(); j++) { + for (int i = 0; i < static_castjetAntiprotons.size(); i++) { + for (int j = i + 1; j < static_castjetAntiprotons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetAntiprotons[i].phi() - jetAntiprotons[j].phi()); double DeltaEta = TMath::Abs(jetAntiprotons[i].eta() - jetAntiprotons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -333,8 +325,8 @@ struct AngularCorrelationsInJets { } } if (jetDeuterons.size() > 1) { - for (int i = 0; i < (int)jetDeuterons.size(); i++) { - for (int j = i + 1; j < (int)jetDeuterons.size(); j++) { + for (int i = 0; i < static_castjetDeuterons.size(); i++) { + for (int j = i + 1; j < static_castjetDeuterons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetDeuterons[i].phi() - jetDeuterons[j].phi()); double DeltaEta = TMath::Abs(jetDeuterons[i].eta() - jetDeuterons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -348,8 +340,8 @@ struct AngularCorrelationsInJets { } } if (jetAntideuterons.size() > 1) { - for (int i = 0; i < (int)jetAntideuterons.size(); i++) { - for (int j = i + 1; j < (int)jetAntideuterons.size(); j++) { + for (int i = 0; i < static_castjetAntideuterons.size(); i++) { + for (int j = i + 1; j < static_castjetAntideuterons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetAntideuterons[i].phi() - jetAntideuterons[j].phi()); double DeltaEta = TMath::Abs(jetAntideuterons[i].eta() - jetAntideuterons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -477,34 +469,34 @@ struct AngularCorrelationsInJets { { switch (particleType) { case 1: - if ((int)fTrackBufferProton.size() == fTrackBufferSize) { + if (static_castfTrackBufferProton.size() == fTrackBufferSize) { fTrackBufferProton.insert(fTrackBufferProton.begin(), track); fTrackBufferProton.resize(fTrackBufferSize); - } else if ((int)fTrackBufferProton.size() < fTrackBufferSize) { + } else if (static_castfTrackBufferProton.size() < fTrackBufferSize) { fTrackBufferProton.emplace_back(track); } break; case 2: - if ((int)fTrackBufferAntiproton.size() == fTrackBufferSize) { + if (static_castfTrackBufferAntiproton.size() == fTrackBufferSize) { fTrackBufferAntiproton.insert(fTrackBufferAntiproton.begin(), track); fTrackBufferAntiproton.resize(fTrackBufferSize); - } else if ((int)fTrackBufferAntiproton.size() < fTrackBufferSize) { + } else if (static_castfTrackBufferAntiproton.size() < fTrackBufferSize) { fTrackBufferAntiproton.emplace_back(track); } break; case 3: - if ((int)fTrackBufferDeuteron.size() == fTrackBufferSize) { + if (static_castfTrackBufferDeuteron.size() == fTrackBufferSize) { fTrackBufferDeuteron.insert(fTrackBufferDeuteron.begin(), track); fTrackBufferDeuteron.resize(fTrackBufferSize); - } else if ((int)fTrackBufferDeuteron.size() < fTrackBufferSize) { + } else if (static_castfTrackBufferDeuteron.size() < fTrackBufferSize) { fTrackBufferDeuteron.emplace_back(track); } break; case 4: - if ((int)fTrackBufferAntideuteron.size() == fTrackBufferSize) { + if (static_castfTrackBufferAntideuteron.size() == fTrackBufferSize) { fTrackBufferAntideuteron.insert(fTrackBufferAntideuteron.begin(), track); fTrackBufferAntideuteron.resize(fTrackBufferSize); - } else if ((int)fTrackBufferAntideuteron.size() < fTrackBufferSize) { + } else if (static_castfTrackBufferAntideuteron.size() < fTrackBufferSize) { fTrackBufferAntideuteron.emplace_back(track); } break; @@ -520,7 +512,7 @@ struct AngularCorrelationsInJets { case 1: if (fTrackBufferProton.size() == 0) return; - for (int i = 0; i < (int)fTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? + for (int i = 0; i < static_castfTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferProton[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferProton[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -530,7 +522,7 @@ struct AngularCorrelationsInJets { case 2: if (fTrackBufferAntiproton.size() == 0) return; - for (int i = 0; i < (int)fTrackBufferAntiproton.size(); i++) { + for (int i = 0; i < static_castfTrackBufferAntiproton.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntiproton[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntiproton[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -540,7 +532,7 @@ struct AngularCorrelationsInJets { case 3: if (fTrackBufferDeuteron.size() == 0) return; - for (int i = 0; i < (int)fTrackBufferDeuteron.size(); i++) { + for (int i = 0; i < static_castfTrackBufferDeuteron.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferDeuteron[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferDeuteron[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -550,7 +542,7 @@ struct AngularCorrelationsInJets { case 4: if (fTrackBufferAntideuteron.size() == 0) return; - for (int i = 0; i < (int)fTrackBufferAntideuteron.size(); i++) { + for (int i = 0; i < static_castfTrackBufferAntideuteron.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntideuteron[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntideuteron[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); From 63bc4d38618a0c5ecfb2521a5474ae4ae3ad8492 Mon Sep 17 00:00:00 2001 From: Lars <146946151+ljoergen@users.noreply.github.com> Date: Fri, 7 Jun 2024 11:22:28 +0200 Subject: [PATCH 12/14] Formatting in AngularCorrelationsInJets.cxx --- .../Nuspex/AngularCorrelationsInJets.cxx | 46 +++++++++---------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index 51d1de3a08a..0a24df9b3db 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -221,7 +221,7 @@ struct AngularCorrelationsInJets { constituents = hardestJet.constituents(); - for (int i = 0; i < static_castconstituents.size(); i++) { + for (int i = 0; i < static_cast constituents.size(); i++) { registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); double DeltaEta = constituents[i].eta() - hardestJet.eta(); @@ -237,7 +237,7 @@ struct AngularCorrelationsInJets { subtractedJet = subtractor(hardestJet); if (subtractedJet.has_constituents()) { - for (int i = 0; i < static_castsubtractedJet.constituents().size(); i++) { + for (int i = 0; i < static_cast subtractedJet.constituents().size(); i++) { registryData.fill(HIST("hPtSubtractedJet"), subtractedJet.constituents()[i].pt()); } } @@ -247,7 +247,7 @@ struct AngularCorrelationsInJets { std::vector jetDeuterons; std::vector jetAntideuterons; - for (int i = 0; i < static_castconstituents.size(); i++) { + for (int i = 0; i < static_cast constituents.size(); i++) { fastjet::PseudoJet pseudoParticle = constituents[i]; int id = pseudoParticle.user_index(); typename TracksType::iterator jetParticle = tracks.iteratorAt(id); @@ -295,8 +295,8 @@ struct AngularCorrelationsInJets { registryData.fill(HIST("hEventProtocol"), 5); if (jetProtons.size() > 1) { - for (int i = 0; i < static_castjetProtons.size(); i++) { - for (int j = i + 1; j < static_castjetProtons.size(); j++) { + for (int i = 0; i < static_cast jetProtons.size(); i++) { + for (int j = i + 1; j < static_cast jetProtons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetProtons[i].phi() - jetProtons[j].phi()); double DeltaEta = TMath::Abs(jetProtons[i].eta() - jetProtons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -310,8 +310,8 @@ struct AngularCorrelationsInJets { } } if (jetAntiprotons.size() > 1) { - for (int i = 0; i < static_castjetAntiprotons.size(); i++) { - for (int j = i + 1; j < static_castjetAntiprotons.size(); j++) { + for (int i = 0; i < static_cast jetAntiprotons.size(); i++) { + for (int j = i + 1; j < static_cast jetAntiprotons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetAntiprotons[i].phi() - jetAntiprotons[j].phi()); double DeltaEta = TMath::Abs(jetAntiprotons[i].eta() - jetAntiprotons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -325,8 +325,8 @@ struct AngularCorrelationsInJets { } } if (jetDeuterons.size() > 1) { - for (int i = 0; i < static_castjetDeuterons.size(); i++) { - for (int j = i + 1; j < static_castjetDeuterons.size(); j++) { + for (int i = 0; i < static_cast jetDeuterons.size(); i++) { + for (int j = i + 1; j < static_cast jetDeuterons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetDeuterons[i].phi() - jetDeuterons[j].phi()); double DeltaEta = TMath::Abs(jetDeuterons[i].eta() - jetDeuterons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -340,8 +340,8 @@ struct AngularCorrelationsInJets { } } if (jetAntideuterons.size() > 1) { - for (int i = 0; i < static_castjetAntideuterons.size(); i++) { - for (int j = i + 1; j < static_castjetAntideuterons.size(); j++) { + for (int i = 0; i < static_cast jetAntideuterons.size(); i++) { + for (int j = i + 1; j < static_cast jetAntideuterons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetAntideuterons[i].phi() - jetAntideuterons[j].phi()); double DeltaEta = TMath::Abs(jetAntideuterons[i].eta() - jetAntideuterons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -469,34 +469,34 @@ struct AngularCorrelationsInJets { { switch (particleType) { case 1: - if (static_castfTrackBufferProton.size() == fTrackBufferSize) { + if (static_cast fTrackBufferProton.size() == fTrackBufferSize) { fTrackBufferProton.insert(fTrackBufferProton.begin(), track); fTrackBufferProton.resize(fTrackBufferSize); - } else if (static_castfTrackBufferProton.size() < fTrackBufferSize) { + } else if (static_cast fTrackBufferProton.size() < fTrackBufferSize) { fTrackBufferProton.emplace_back(track); } break; case 2: - if (static_castfTrackBufferAntiproton.size() == fTrackBufferSize) { + if (static_cast fTrackBufferAntiproton.size() == fTrackBufferSize) { fTrackBufferAntiproton.insert(fTrackBufferAntiproton.begin(), track); fTrackBufferAntiproton.resize(fTrackBufferSize); - } else if (static_castfTrackBufferAntiproton.size() < fTrackBufferSize) { + } else if (static_cast fTrackBufferAntiproton.size() < fTrackBufferSize) { fTrackBufferAntiproton.emplace_back(track); } break; case 3: - if (static_castfTrackBufferDeuteron.size() == fTrackBufferSize) { + if (static_cast fTrackBufferDeuteron.size() == fTrackBufferSize) { fTrackBufferDeuteron.insert(fTrackBufferDeuteron.begin(), track); fTrackBufferDeuteron.resize(fTrackBufferSize); - } else if (static_castfTrackBufferDeuteron.size() < fTrackBufferSize) { + } else if (static_cast fTrackBufferDeuteron.size() < fTrackBufferSize) { fTrackBufferDeuteron.emplace_back(track); } break; case 4: - if (static_castfTrackBufferAntideuteron.size() == fTrackBufferSize) { + if (static_cast fTrackBufferAntideuteron.size() == fTrackBufferSize) { fTrackBufferAntideuteron.insert(fTrackBufferAntideuteron.begin(), track); fTrackBufferAntideuteron.resize(fTrackBufferSize); - } else if (static_castfTrackBufferAntideuteron.size() < fTrackBufferSize) { + } else if (static_cast fTrackBufferAntideuteron.size() < fTrackBufferSize) { fTrackBufferAntideuteron.emplace_back(track); } break; @@ -512,7 +512,7 @@ struct AngularCorrelationsInJets { case 1: if (fTrackBufferProton.size() == 0) return; - for (int i = 0; i < static_castfTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? + for (int i = 0; i < static_cast fTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferProton[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferProton[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -522,7 +522,7 @@ struct AngularCorrelationsInJets { case 2: if (fTrackBufferAntiproton.size() == 0) return; - for (int i = 0; i < static_castfTrackBufferAntiproton.size(); i++) { + for (int i = 0; i < static_cast fTrackBufferAntiproton.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntiproton[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntiproton[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -532,7 +532,7 @@ struct AngularCorrelationsInJets { case 3: if (fTrackBufferDeuteron.size() == 0) return; - for (int i = 0; i < static_castfTrackBufferDeuteron.size(); i++) { + for (int i = 0; i < static_cast fTrackBufferDeuteron.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferDeuteron[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferDeuteron[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -542,7 +542,7 @@ struct AngularCorrelationsInJets { case 4: if (fTrackBufferAntideuteron.size() == 0) return; - for (int i = 0; i < static_castfTrackBufferAntideuteron.size(); i++) { + for (int i = 0; i < static_cast fTrackBufferAntideuteron.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntideuteron[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntideuteron[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); From 7658955f568cc421aa7eee73bdde87b876fc1a33 Mon Sep 17 00:00:00 2001 From: Lars <146946151+ljoergen@users.noreply.github.com> Date: Fri, 7 Jun 2024 15:18:33 +0200 Subject: [PATCH 13/14] Removed casts in AngularCorrelationsInJets.cxx --- .../Nuspex/AngularCorrelationsInJets.cxx | 30 +++++++++---------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index 0a24df9b3db..b474700062b 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -221,7 +221,7 @@ struct AngularCorrelationsInJets { constituents = hardestJet.constituents(); - for (int i = 0; i < static_cast constituents.size(); i++) { + for (int i = 0; i < constituents.size(); i++) { registryData.fill(HIST("hPtJetParticle"), constituents[i].pt()); double DeltaPhi = TVector2::Phi_0_2pi(constituents[i].phi() - hardestJet.phi()); double DeltaEta = constituents[i].eta() - hardestJet.eta(); @@ -237,7 +237,7 @@ struct AngularCorrelationsInJets { subtractedJet = subtractor(hardestJet); if (subtractedJet.has_constituents()) { - for (int i = 0; i < static_cast subtractedJet.constituents().size(); i++) { + for (int i = 0; i < subtractedJet.constituents().size(); i++) { registryData.fill(HIST("hPtSubtractedJet"), subtractedJet.constituents()[i].pt()); } } @@ -247,7 +247,7 @@ struct AngularCorrelationsInJets { std::vector jetDeuterons; std::vector jetAntideuterons; - for (int i = 0; i < static_cast constituents.size(); i++) { + for (int i = 0; i < constituents.size(); i++) { fastjet::PseudoJet pseudoParticle = constituents[i]; int id = pseudoParticle.user_index(); typename TracksType::iterator jetParticle = tracks.iteratorAt(id); @@ -295,8 +295,8 @@ struct AngularCorrelationsInJets { registryData.fill(HIST("hEventProtocol"), 5); if (jetProtons.size() > 1) { - for (int i = 0; i < static_cast jetProtons.size(); i++) { - for (int j = i + 1; j < static_cast jetProtons.size(); j++) { + for (int i = 0; i < jetProtons.size(); i++) { + for (int j = i + 1; j < jetProtons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetProtons[i].phi() - jetProtons[j].phi()); double DeltaEta = TMath::Abs(jetProtons[i].eta() - jetProtons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -310,8 +310,8 @@ struct AngularCorrelationsInJets { } } if (jetAntiprotons.size() > 1) { - for (int i = 0; i < static_cast jetAntiprotons.size(); i++) { - for (int j = i + 1; j < static_cast jetAntiprotons.size(); j++) { + for (int i = 0; i < jetAntiprotons.size(); i++) { + for (int j = i + 1; j < jetAntiprotons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetAntiprotons[i].phi() - jetAntiprotons[j].phi()); double DeltaEta = TMath::Abs(jetAntiprotons[i].eta() - jetAntiprotons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -325,8 +325,8 @@ struct AngularCorrelationsInJets { } } if (jetDeuterons.size() > 1) { - for (int i = 0; i < static_cast jetDeuterons.size(); i++) { - for (int j = i + 1; j < static_cast jetDeuterons.size(); j++) { + for (int i = 0; i < jetDeuterons.size(); i++) { + for (int j = i + 1; j < jetDeuterons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetDeuterons[i].phi() - jetDeuterons[j].phi()); double DeltaEta = TMath::Abs(jetDeuterons[i].eta() - jetDeuterons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -340,8 +340,8 @@ struct AngularCorrelationsInJets { } } if (jetAntideuterons.size() > 1) { - for (int i = 0; i < static_cast jetAntideuterons.size(); i++) { - for (int j = i + 1; j < static_cast jetAntideuterons.size(); j++) { + for (int i = 0; i < jetAntideuterons.size(); i++) { + for (int j = i + 1; j < jetAntideuterons.size(); j++) { double DeltaPhi = TVector2::Phi_0_2pi(jetAntideuterons[i].phi() - jetAntideuterons[j].phi()); double DeltaEta = TMath::Abs(jetAntideuterons[i].eta() - jetAntideuterons[j].eta()); if (DeltaPhi > (1.5 * TMath::Pi())) { @@ -512,7 +512,7 @@ struct AngularCorrelationsInJets { case 1: if (fTrackBufferProton.size() == 0) return; - for (int i = 0; i < static_cast fTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? + for (int i = 0; i < fTrackBufferProton.size(); i++) { // can I do this even if the track buffer isn't even full yet? double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferProton[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferProton[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -522,7 +522,7 @@ struct AngularCorrelationsInJets { case 2: if (fTrackBufferAntiproton.size() == 0) return; - for (int i = 0; i < static_cast fTrackBufferAntiproton.size(); i++) { + for (int i = 0; i < fTrackBufferAntiproton.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntiproton[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntiproton[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -532,7 +532,7 @@ struct AngularCorrelationsInJets { case 3: if (fTrackBufferDeuteron.size() == 0) return; - for (int i = 0; i < static_cast fTrackBufferDeuteron.size(); i++) { + for (int i = 0; i < fTrackBufferDeuteron.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferDeuteron[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferDeuteron[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); @@ -542,7 +542,7 @@ struct AngularCorrelationsInJets { case 4: if (fTrackBufferAntideuteron.size() == 0) return; - for (int i = 0; i < static_cast fTrackBufferAntideuteron.size(); i++) { + for (int i = 0; i < fTrackBufferAntideuteron.size(); i++) { double DeltaPhi = TVector2::Phi_0_2pi(track.phi() - fTrackBufferAntideuteron[i].phi()); double DeltaEta = TMath::Abs(track.eta() - fTrackBufferAntideuteron[i].eta()); registryData.fill(HIST("hDeltaPhiME"), particleType, DeltaPhi); From b8db6e7ef95ea5b6649fe5f32c83e612c50449bf Mon Sep 17 00:00:00 2001 From: Lars <146946151+ljoergen@users.noreply.github.com> Date: Fri, 7 Jun 2024 18:42:07 +0200 Subject: [PATCH 14/14] Update AngularCorrelationsInJets.cxx --- PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx index b474700062b..7951e306696 100644 --- a/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx +++ b/PWGLF/Tasks/Nuspex/AngularCorrelationsInJets.cxx @@ -469,34 +469,34 @@ struct AngularCorrelationsInJets { { switch (particleType) { case 1: - if (static_cast fTrackBufferProton.size() == fTrackBufferSize) { + if (fTrackBufferProton.size() == fTrackBufferSize) { fTrackBufferProton.insert(fTrackBufferProton.begin(), track); fTrackBufferProton.resize(fTrackBufferSize); - } else if (static_cast fTrackBufferProton.size() < fTrackBufferSize) { + } else if (fTrackBufferProton.size() < fTrackBufferSize) { fTrackBufferProton.emplace_back(track); } break; case 2: - if (static_cast fTrackBufferAntiproton.size() == fTrackBufferSize) { + if (fTrackBufferAntiproton.size() == fTrackBufferSize) { fTrackBufferAntiproton.insert(fTrackBufferAntiproton.begin(), track); fTrackBufferAntiproton.resize(fTrackBufferSize); - } else if (static_cast fTrackBufferAntiproton.size() < fTrackBufferSize) { + } else if (fTrackBufferAntiproton.size() < fTrackBufferSize) { fTrackBufferAntiproton.emplace_back(track); } break; case 3: - if (static_cast fTrackBufferDeuteron.size() == fTrackBufferSize) { + if (fTrackBufferDeuteron.size() == fTrackBufferSize) { fTrackBufferDeuteron.insert(fTrackBufferDeuteron.begin(), track); fTrackBufferDeuteron.resize(fTrackBufferSize); - } else if (static_cast fTrackBufferDeuteron.size() < fTrackBufferSize) { + } else if (fTrackBufferDeuteron.size() < fTrackBufferSize) { fTrackBufferDeuteron.emplace_back(track); } break; case 4: - if (static_cast fTrackBufferAntideuteron.size() == fTrackBufferSize) { + if (fTrackBufferAntideuteron.size() == fTrackBufferSize) { fTrackBufferAntideuteron.insert(fTrackBufferAntideuteron.begin(), track); fTrackBufferAntideuteron.resize(fTrackBufferSize); - } else if (static_cast fTrackBufferAntideuteron.size() < fTrackBufferSize) { + } else if (fTrackBufferAntideuteron.size() < fTrackBufferSize) { fTrackBufferAntideuteron.emplace_back(track); } break;