From 2e43b1cd65128e14e96c8ce18f3aeecf7b3026cf Mon Sep 17 00:00:00 2001 From: PaolaVT Date: Tue, 29 Jul 2025 13:29:02 -0600 Subject: [PATCH 1/7] Phi parametrizations were updated --- PWGMM/UE/Tasks/dedxAnalysis.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGMM/UE/Tasks/dedxAnalysis.cxx b/PWGMM/UE/Tasks/dedxAnalysis.cxx index b87e9c30478..11aea4031be 100644 --- a/PWGMM/UE/Tasks/dedxAnalysis.cxx +++ b/PWGMM/UE/Tasks/dedxAnalysis.cxx @@ -146,8 +146,8 @@ struct DedxAnalysis { AxisSpec ptAxis = {binP, "pT (GeV/c)"}; AxisSpec etaAxis{8, -0.8, 0.8, "#eta"}; AxisSpec pAxis = {binP, "#it{p}/Z (GeV/c)"}; - fphiCutLow = new TF1("StandardPhiCutLow", "0.1/x/x+pi/18.0-0.025", 0, 50); - fphiCutHigh = new TF1("StandardPhiCutHigh", "0.12/x+pi/18.0+0.035", 0, 50); + fphiCutLow = new TF1("StandardPhiCutLow", "0.119297/x/x+pi/18.0-0.000379693", 0, 50); + fphiCutHigh = new TF1("StandardPhiCutHigh", "0.16685/x+pi/18.0+0.00981942", 0, 50); if (calibrationMode) { // MIP for pions registryDeDx.add( From 49fe700df785d0753bb9b46c898f4174de8fb842 Mon Sep 17 00:00:00 2001 From: PaolaVT Date: Fri, 1 Aug 2025 13:14:30 -0600 Subject: [PATCH 2/7] The analysis task dedxPidAnalysis.cxx was added --- PWGLF/Tasks/Nuspex/CMakeLists.txt | 5 + PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx | 852 +++++++++++++++++++++++++ 2 files changed, 857 insertions(+) create mode 100644 PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx diff --git a/PWGLF/Tasks/Nuspex/CMakeLists.txt b/PWGLF/Tasks/Nuspex/CMakeLists.txt index 05b1bc2ca8e..8e86feab651 100644 --- a/PWGLF/Tasks/Nuspex/CMakeLists.txt +++ b/PWGLF/Tasks/Nuspex/CMakeLists.txt @@ -150,4 +150,9 @@ o2physics_add_dpl_workflow(he3-lambda-derived-analysis PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(dedx-pid-analysis + SOURCES dedxPidAnalysis.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + endif() diff --git a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx new file mode 100644 index 00000000000..d688f0c8e72 --- /dev/null +++ b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx @@ -0,0 +1,852 @@ +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. +// All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \author Paola Vargas Torres (paola.vargas.torres@cern.ch) +/// \since January 8, 2025 +/// \file dedxPidAnalysis.cxx +/// \brief Analysis to do PID + +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/Core/RecoDecay.h" +#include "Common/Core/TrackSelection.h" +#include "Common/Core/TrackSelectionDefaults.h" +#include "Common/Core/trackUtilities.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/PIDResponse.h" +#include "Common/DataModel/TrackSelectionTables.h" + +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" +#include "ReconstructionDataFormats/Track.h" + +#include "TF1.h" + +using namespace o2; +using namespace o2::framework; +using namespace constants::physics; + +using PIDTracks = soa::Join< + aod::Tracks, aod::TracksExtra, aod::TrackSelectionExtension, aod::TracksDCA, aod::TrackSelection, + aod::pidTOFFullPi, aod::pidTOFFullPr, aod::pidTOFFullEl, aod::pidTOFbeta>; + +using SelectedCollisions = soa::Join; + +struct DedxPidAnalysis { + + // dE/dx for all charged particles + HistogramRegistry registryDeDx{ + "registryDeDx", + {}, + OutputObjHandlingPolicy::AnalysisObject, + true, + true}; + // Constant values + static constexpr int kEtaIntervals = 8; + static constexpr int kParticlesType = 4; + float tpcCut = 0.6; + float pionMin = 0.35; + float pionMax = 0.45; + float elTofCut = 0.1; + float pionTofCut = 1.0; + float invMassCut = 0.01; + float invMassCutGamma = 0.0015; + float magField = 1; + float pTcut = 2.0; + + // Configurable Parameters + // Tracks cuts + Configurable minTPCnClsFound{"minTPCnClsFound", 70.0f, + "min number of found TPC clusters"}; + Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of found TPC crossed rows"}; + Configurable maxChi2TPC{"maxChi2TPC", 4.0f, + "max chi2 per cluster TPC"}; + Configurable maxChi2ITS{"maxChi2ITS", 36.0f, + "max chi2 per cluster ITS"}; + Configurable maxZDistanceToIP{"maxZDistanceToIP", 10.0f, + "max z distance to IP"}; + Configurable etaMin{"etaMin", -0.8f, "etaMin"}; + Configurable etaMax{"etaMax", +0.8f, "etaMax"}; + Configurable minNCrossedRowsOverFindableClustersTPC{"minNCrossedRowsOverFindableClustersTPC", 0.8f, "Additional cut on the minimum value of the ratio between crossed rows and findable clusters in the TPC"}; + Configurable maxDCAz{"maxDCAz", 2.f, "maxDCAz"}; + // v0 cuts + Configurable v0cospaMin{"v0cospaMin", 0.998f, "Minimum V0 CosPA"}; + Configurable minimumV0Radius{"minimumV0Radius", 0.5f, + "Minimum V0 Radius"}; + Configurable maximumV0Radius{"maximumV0Radius", 100.0f, + "Maximum V0 Radius"}; + Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 0.5f, + "Maximum DCA Daughters"}; + Configurable nsigmaTOFmax{"nsigmaTOFmax", 3.0f, "Maximum nsigma TOF"}; + Configurable minMassK0s{"minMassK0s", 0.4f, "Minimum Mass K0s"}; + Configurable maxMassK0s{"maxMassK0s", 0.6f, "Maximum Mass K0s"}; + Configurable minMassLambda{"minMassLambda", 1.1f, + "Minimum Mass Lambda"}; + Configurable maxMassLambda{"maxMassLambda", 1.2f, + "Maximum Mass Lambda"}; + Configurable minMassGamma{"minMassGamma", 0.000922f, + "Minimum Mass Gamma"}; + Configurable maxMassGamma{"maxMassGamma", 0.002022f, + "Maximum Mass Gamma"}; + Configurable nclCut{"nclCut", 135.0f, + "ncl Cut"}; + Configurable calibrationMode{"calibrationMode", false, "calibration mode"}; + Configurable additionalCuts{"additionalCuts", true, "additional cuts"}; + // Histograms names + static constexpr std::string_view kDedxvsMomentumPos[kParticlesType] = {"dEdx_vs_Momentum_all_Pos", "dEdx_vs_Momentum_Pi_v0_Pos", "dEdx_vs_Momentum_Pr_v0_Pos", "dEdx_vs_Momentum_El_v0_Pos"}; + static constexpr std::string_view kDedxvsMomentumNeg[kParticlesType] = {"dEdx_vs_Momentum_all_Neg", "dEdx_vs_Momentum_Pi_v0_Neg", "dEdx_vs_Momentum_Pr_v0_Neg", "dEdx_vs_Momentum_El_v0_Neg"}; + static constexpr std::string_view kNclDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_8_Before"}; + static constexpr std::string_view kNclDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_8_Before"}; + static constexpr std::string_view kNclDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_vs_dEdx_vs_Momentum_Neg_8_After"}; + static constexpr std::string_view kNclDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_vs_dEdx_vs_Momentum_Pos_8_After"}; + static constexpr double EtaCut[kEtaIntervals + 1] = {-0.8, -0.6, -0.4, -0.2, 0.0, 0.2, 0.4, 0.6, 0.8}; + Configurable> calibrationFactorNeg{"calibrationFactorNeg", {50.4011, 50.4764, 50.186, 49.2955, 48.8222, 49.4273, 49.9292, 50.0556}, "negative calibration factors"}; + Configurable> calibrationFactorPos{"calibrationFactorPos", {50.5157, 50.6359, 50.3198, 49.3345, 48.9197, 49.4931, 50.0188, 50.1406}, "positive calibration factors"}; + ConfigurableAxis binP{"binP", {VARIABLE_WIDTH, 0.1, 0.12, 0.14, 0.16, 0.18, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 18.0, 20.0}, ""}; + + // phi cut fits + TF1* fphiCutHigh = nullptr; + TF1* fphiCutLow = nullptr; + + TrackSelection myTrackSelection() + { + TrackSelection selectedTracks; + selectedTracks.SetPtRange(0.1f, 1e10f); + selectedTracks.SetEtaRange(etaMin, etaMax); + selectedTracks.SetRequireITSRefit(true); + selectedTracks.SetRequireTPCRefit(true); + selectedTracks.SetMinNCrossedRowsTPC(minNCrossedRowsTPC); + selectedTracks.SetMinNCrossedRowsOverFindableClustersTPC(minNCrossedRowsOverFindableClustersTPC); + selectedTracks.SetMaxChi2PerClusterTPC(maxChi2TPC); + selectedTracks.SetRequireHitsInITSLayers(1, {0, 1}); + selectedTracks.SetMaxChi2PerClusterITS(maxChi2ITS); + selectedTracks.SetMaxDcaXYPtDep([](float pt) { return 0.0105f + 0.0350f / std::pow(pt, 1.1f); }); + selectedTracks.SetMaxDcaZ(maxDCAz); + selectedTracks.SetRequireGoldenChi2(true); + + return selectedTracks; + } + + TrackSelection mySelectionPrim; + + void init(InitContext const&) + { + AxisSpec dedxAxis{100, 0.0, 100.0, "dE/dx (a. u.)"}; + AxisSpec ptAxis = {binP, "pT (GeV/c)"}; + AxisSpec etaAxis{8, -0.8, 0.8, "#eta"}; + AxisSpec pAxis = {binP, "#it{p}/Z (GeV/c)"}; + fphiCutLow = new TF1("StandardPhiCutLow", "0.119297/x/x+pi/18.0-0.000379693", 0, 50); + fphiCutHigh = new TF1("StandardPhiCutHigh", "0.16685/x+pi/18.0+0.00981942", 0, 50); + if (calibrationMode) { + // MIP for pions + registryDeDx.add( + "hdEdx_vs_eta_Neg_Pi", "dE/dx", HistType::kTH2F, + {{etaAxis}, {dedxAxis}}); + registryDeDx.add( + "hdEdx_vs_eta_Pos_Pi", "dE/dx", HistType::kTH2F, + {{etaAxis}, {dedxAxis}}); + // MIP for electrons + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Neg_El", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Pos_El", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + // Pions from TOF + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Neg_TOF", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Pos_TOF", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + + } else { + // MIP for pions + registryDeDx.add( + "hdEdx_vs_eta_Neg_calibrated_Pi", "dE/dx", HistType::kTH2F, + {{etaAxis}, {dedxAxis}}); + + registryDeDx.add( + "hdEdx_vs_eta_Pos_calibrated_Pi", "dE/dx", HistType::kTH2F, + {{etaAxis}, {dedxAxis}}); + + // MIP for electrons + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Neg_calibrated_El", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Pos_calibrated_El", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + + // Pions from TOF + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Neg_calibrated_TOF", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + + registryDeDx.add( + "hdEdx_vs_eta_vs_p_Pos_calibrated_TOF", "dE/dx", HistType::kTH3F, + {{etaAxis}, {dedxAxis}, {pAxis}}); + + // pt vs p + registryDeDx.add( + "hp_vs_pt_all_Neg", "p_vs_pT", HistType::kTH2F, + {{ptAxis}, {pAxis}}); + registryDeDx.add( + "hp_vs_pt_all_Pos", "p_vs_pT", HistType::kTH2F, + {{ptAxis}, {pAxis}}); + + // De/Dx for ch and v0 particles + for (int i = 0; i < kParticlesType; ++i) { + registryDeDx.add(kDedxvsMomentumPos[i].data(), "dE/dx", HistType::kTH3F, + {{pAxis}, {dedxAxis}, {etaAxis}}); + registryDeDx.add(kDedxvsMomentumNeg[i].data(), "dE/dx", HistType::kTH3F, + {{pAxis}, {dedxAxis}, {etaAxis}}); + } + } + + registryDeDx.add( + "hdEdx_vs_phi", "dE/dx", HistType::kTH2F, + {{100, 0.0, 6.4, "#phi"}, {dedxAxis}}); + + // phi cut + registryDeDx.add( + "hpt_vs_phi_Ncl_After", "phi cut", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); + + registryDeDx.add( + "hpt_vs_phi_Ncl_Before", "phi cut", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); + + // Ncl vs de/dx + + for (int i = 0; i < kEtaIntervals; ++i) { + registryDeDx.add(kNclDedxMomentumPosBefore[i].data(), "Ncl vs dE/dx vs Momentum Positive before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclDedxMomentumNegBefore[i].data(), "Ncl vs dE/dx vs Momentum Negative before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + + registryDeDx.add(kNclDedxMomentumPosAfter[i].data(), "Ncl vs dE/dx vs Momentum Positive after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclDedxMomentumNegAfter[i].data(), "Ncl vs dE/dx vs Momentum Negative after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + } + + // beta plot + registryDeDx.add( + "hbeta_vs_p_Neg", "beta", HistType::kTH2F, + {{pAxis}, {100, 0.0, 1.1, "#beta"}}); + + registryDeDx.add( + "hbeta_vs_p_Pos", "beta", HistType::kTH2F, + {{pAxis}, {100, 0.0, 1.1, "#beta"}}); + + // Event Counter + registryDeDx.add("histRecVtxZData", "collision z position", HistType::kTH1F, {{100, -20.0, +20.0, "z_{vtx} (cm)"}}); + + mySelectionPrim = myTrackSelection(); + } + + // Single-Track Selection + template + bool passedSingleTrackSelection(const T1& track, const C& /*collision*/) + { + // Single-Track Selections + if (!track.hasTPC()) + return false; + if (track.tpcNClsFound() < minTPCnClsFound) + return false; + if (track.tpcNClsCrossedRows() < minNCrossedRowsTPC) + return false; + if (track.tpcChi2NCl() > maxChi2TPC) + return false; + if (track.eta() < etaMin || track.eta() > etaMax) + return false; + + return true; + } + + // General V0 Selections + template + bool passedV0Selection(const T1& v0, const C& /*collision*/) + { + if (v0.v0cosPA() < v0cospaMin) + return false; + if (v0.v0radius() < minimumV0Radius || v0.v0radius() > maximumV0Radius) + return false; + + return true; + } + + // K0s Selections + template + bool passedK0Selection(const T1& v0, const T2& ntrack, const T2& ptrack, + const C& collision) + { + // Single-Track Selections + if (!passedSingleTrackSelection(ptrack, collision)) + return false; + if (!passedSingleTrackSelection(ntrack, collision)) + return false; + + if (ptrack.tpcInnerParam() > tpcCut) { + if (!ptrack.hasTOF()) + return false; + if (std::abs(ptrack.tofNSigmaPi()) > nsigmaTOFmax) + return false; + } + + if (ntrack.tpcInnerParam() > tpcCut) { + if (!ntrack.hasTOF()) + return false; + if (std::abs(ntrack.tofNSigmaPi()) > nsigmaTOFmax) + return false; + } + + // Invariant-Mass Selection + if (v0.mK0Short() < minMassK0s || v0.mK0Short() > maxMassK0s) + return false; + + return true; + } + + // Lambda Selections + template + bool passedLambdaSelection(const T1& v0, const T2& ntrack, const T2& ptrack, + const C& collision) + { + // Single-Track Selections + if (!passedSingleTrackSelection(ptrack, collision)) + return false; + if (!passedSingleTrackSelection(ntrack, collision)) + return false; + + if (ptrack.tpcInnerParam() > tpcCut) { + if (!ptrack.hasTOF()) + return false; + if (std::abs(ptrack.tofNSigmaPr()) > nsigmaTOFmax) + return false; + } + + if (ntrack.tpcInnerParam() > tpcCut) { + if (!ntrack.hasTOF()) + return false; + if (std::abs(ntrack.tofNSigmaPi()) > nsigmaTOFmax) + return false; + } + + // Invariant-Mass Selection + if (v0.mLambda() < minMassLambda || v0.mLambda() > maxMassLambda) + return false; + + return true; + } + + // AntiLambda Selections + template + bool passedAntiLambdaSelection(const T1& v0, const T2& ntrack, + const T2& ptrack, const C& collision) + { + + // Single-Track Selections + if (!passedSingleTrackSelection(ptrack, collision)) + return false; + if (!passedSingleTrackSelection(ntrack, collision)) + return false; + + if (ptrack.tpcInnerParam() > tpcCut) { + if (!ptrack.hasTOF()) + return false; + if (std::abs(ptrack.tofNSigmaPi()) > nsigmaTOFmax) + return false; + } + + if (ntrack.tpcInnerParam() > tpcCut) { + if (!ntrack.hasTOF()) + return false; + if (std::abs(ntrack.tofNSigmaPr()) > nsigmaTOFmax) + return false; + } + + // Invariant-Mass Selection + if (v0.mAntiLambda() < minMassLambda || v0.mAntiLambda() > maxMassLambda) + return false; + + return true; + } + + // Gamma Selections + template + bool passedGammaSelection(const T1& v0, const T2& ntrack, const T2& ptrack, + const C& collision) + { + // Single-Track Selections + if (!passedSingleTrackSelection(ptrack, collision)) + return false; + if (!passedSingleTrackSelection(ntrack, collision)) + return false; + + if (ptrack.tpcInnerParam() > tpcCut) { + if (!ptrack.hasTOF()) + return false; + if (std::abs(ptrack.tofNSigmaEl()) > nsigmaTOFmax) + return false; + } + + if (ntrack.tpcInnerParam() > tpcCut) { + if (!ntrack.hasTOF()) + return false; + if (std::abs(ntrack.tofNSigmaEl()) > nsigmaTOFmax) + return false; + } + + // Invariant-Mass Selection + if (v0.mGamma() < minMassGamma || v0.mGamma() > maxMassGamma) + return false; + + return true; + } + + // Phi cut + template + bool passedPhiCut(const T& trk, float magField, const TF1& fphiCutLow, const TF1& fphiCutHigh) + { + float pt = trk.pt(); + float phi = trk.phi(); + int charge = trk.sign(); + float eta = trk.eta(); + auto nTPCCl = trk.tpcNClsFindable() - trk.tpcNClsFindableMinusFound(); + float sigP = trk.sign() * trk.tpcInnerParam(); + + if (pt < pTcut) + return true; + + if (magField < 0) // for negatve polarity field + phi = o2::constants::math::TwoPI - phi; + if (charge < 0) // for negatve charge + phi = o2::constants::math::TwoPI - phi; + + // to center gap in the middle + phi += o2::constants::math::PI / 18.0f; + phi = std::fmod(phi, o2::constants::math::PI / 9.0f); + + registryDeDx.fill(HIST("hpt_vs_phi_Ncl_Before"), pt, phi, nTPCCl); + + // cut phi + if (phi < fphiCutHigh.Eval(pt) && phi > fphiCutLow.Eval(pt)) + return false; // reject track + + if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[0]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[1]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[2]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[3]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[4]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[5]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[6]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[7]), nTPCCl, trk.tpcSignal(), sigP); + } + } + + // cut Ncl + if (nTPCCl < nclCut) + return false; + + registryDeDx.fill(HIST("hpt_vs_phi_Ncl_After"), pt, phi, nTPCCl); + + if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[0]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[1]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[2]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[3]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[4]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[5]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[6]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[7]), nTPCCl, trk.tpcSignal(), sigP); + } + } + + return true; + } + + // Phi cut Secondaries + template + bool passedPhiCutSecondaries(const T& trk, float magField, const TF1& fphiCutLow, const TF1& fphiCutHigh) + { + float pt = trk.pt(); + float phi = trk.phi(); + int charge = trk.sign(); + auto nTPCCl = trk.tpcNClsFindable() - trk.tpcNClsFindableMinusFound(); + + if (pt < pTcut) + return true; + + if (magField < 0) // for negatve polarity field + phi = o2::constants::math::TwoPI - phi; + if (charge < 0) // for negatve charge + phi = o2::constants::math::TwoPI - phi; + + // to center gap in the middle + phi += o2::constants::math::PI / 18.0f; + phi = std::fmod(phi, o2::constants::math::PI / 9.0f); + + // cut phi + if (phi < fphiCutHigh.Eval(pt) && phi > fphiCutLow.Eval(pt)) + return false; // reject track + + // cut Ncl + if (nTPCCl < nclCut) + return false; + + return true; + } + + // Process Data + void process(SelectedCollisions::iterator const& collision, + aod::V0Datas const& fullV0s, PIDTracks const& tracks) + { + // Event Selection + if (!collision.sel8()) + return; + + if (additionalCuts) { + if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) + return; + + if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) + return; + + if (std::abs(collision.posZ()) >= maxZDistanceToIP) + return; + + if (!collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) + return; + } + + // Event Counter + registryDeDx.fill(HIST("histRecVtxZData"), collision.posZ()); + + // Kaons + for (const auto& trk : tracks) { + + // track Selection + if (!passedSingleTrackSelection(trk, collision)) + continue; + + if (!mySelectionPrim.IsSelected(trk)) + continue; + + // phi and Ncl cut + if (!passedPhiCut(trk, magField, *fphiCutLow, *fphiCutHigh)) + continue; + + float signedP = trk.sign() * trk.tpcInnerParam(); + + // MIP calibration for pions + if (trk.tpcInnerParam() >= pionMin && trk.tpcInnerParam() <= pionMax) { + if (calibrationMode) { + if (signedP < 0) { + registryDeDx.fill(HIST("hdEdx_vs_eta_Neg_Pi"), trk.eta(), trk.tpcSignal()); + } else { + registryDeDx.fill(HIST("hdEdx_vs_eta_Pos_Pi"), trk.eta(), trk.tpcSignal()); + } + + } else { + for (int i = 0; i < kEtaIntervals; ++i) { + if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + if (signedP < 0) { + registryDeDx.fill(HIST("hdEdx_vs_eta_Neg_calibrated_Pi"), trk.eta(), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i)); + } else { + registryDeDx.fill(HIST("hdEdx_vs_eta_Pos_calibrated_Pi"), trk.eta(), trk.tpcSignal() * 50 / calibrationFactorPos->at(i)); + } + } + } + } + } + // Beta from TOF + if (signedP < 0) { + registryDeDx.fill(HIST("hbeta_vs_p_Neg"), std::abs(signedP), trk.beta()); + } else { + registryDeDx.fill(HIST("hbeta_vs_p_Pos"), signedP, trk.beta()); + } + // Electrons from TOF + if (std::abs(trk.beta() - 1) < elTofCut) { // beta cut + if (calibrationMode) { + if (signedP < 0) { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Neg_El"), trk.eta(), trk.tpcSignal(), std::abs(signedP)); + } else { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Pos_El"), trk.eta(), trk.tpcSignal(), signedP); + } + } else { + for (int i = 0; i < kEtaIntervals; ++i) { + if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + if (signedP < 0) { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Neg_calibrated_El"), trk.eta(), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i), std::abs(signedP)); + } else { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Pos_calibrated_El"), trk.eta(), trk.tpcSignal() * 50 / calibrationFactorPos->at(i), signedP); + } + } + } + } + } + // pions from TOF + if (trk.beta() > pionTofCut && trk.beta() < pionTofCut + 0.05) { // beta cut + if (calibrationMode) { + if (signedP < 0) { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Neg_TOF"), trk.eta(), trk.tpcSignal(), std::abs(signedP)); + } else { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Pos_TOF"), trk.eta(), trk.tpcSignal(), signedP); + } + } else { + for (int i = 0; i < kEtaIntervals; ++i) { + if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + if (signedP < 0) { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Neg_calibrated_TOF"), trk.eta(), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i), std::abs(signedP)); + } else { + registryDeDx.fill(HIST("hdEdx_vs_eta_vs_p_Pos_calibrated_TOF"), trk.eta(), trk.tpcSignal() * 50 / calibrationFactorPos->at(i), signedP); + } + } + } + } + } + + registryDeDx.fill(HIST("hdEdx_vs_phi"), trk.phi(), trk.tpcSignal()); + + if (!calibrationMode) { + for (int i = 0; i < kEtaIntervals; ++i) { + if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + if (signedP > 0) { + registryDeDx.fill(HIST(kDedxvsMomentumPos[0]), signedP, trk.tpcSignal() * 50 / calibrationFactorPos->at(i), trk.eta()); + registryDeDx.fill(HIST("hp_vs_pt_all_Pos"), trk.pt(), signedP); + } else { + registryDeDx.fill(HIST(kDedxvsMomentumNeg[0]), std::abs(signedP), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i), trk.eta()); + registryDeDx.fill(HIST("hp_vs_pt_all_Neg"), trk.pt(), std::abs(signedP)); + } + } + } + } + } + + // Loop over Reconstructed V0s + if (!calibrationMode) { + for (const auto& v0 : fullV0s) { + + // Standard V0 Selections + if (!passedV0Selection(v0, collision)) { + continue; + } + + if (v0.dcaV0daughters() > dcaV0DaughtersMax) { + continue; + } + + // Positive and Negative Tracks + const auto& posTrack = v0.posTrack_as(); + const auto& negTrack = v0.negTrack_as(); + + if (!posTrack.passedTPCRefit()) + continue; + if (!negTrack.passedTPCRefit()) + continue; + // phi and Ncl cut + if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; + + if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; + + float signedPpos = posTrack.sign() * posTrack.tpcInnerParam(); + float signedPneg = negTrack.sign() * negTrack.tpcInnerParam(); + + float pxPos = posTrack.px(); + float pyPos = posTrack.py(); + float pzPos = posTrack.pz(); + + float pxNeg = negTrack.px(); + float pyNeg = negTrack.py(); + float pzNeg = negTrack.pz(); + + const float gammaMass = 2 * MassElectron; // GeV/c^2 + + // K0s Selection + if (passedK0Selection(v0, negTrack, posTrack, collision)) { + float ePosPi = posTrack.energy(MassPionCharged); + float eNegPi = negTrack.energy(MassPionCharged); + + float invMass = std::sqrt((eNegPi + ePosPi) * (eNegPi + ePosPi) - ((pxNeg + pxPos) * (pxNeg + pxPos) + (pyNeg + pyPos) * (pyNeg + pyPos) + (pzNeg + pzPos) * (pzNeg + pzPos))); + + if (std::abs(invMass - MassK0Short) > invMassCut) { + continue; + } + + for (int i = 0; i < kEtaIntervals; ++i) { + if (negTrack.eta() > EtaCut[i] && negTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumNeg[1]), std::abs(signedPneg), negTrack.tpcSignal() * 50 / calibrationFactorNeg->at(i), negTrack.eta()); + } + if (posTrack.eta() > EtaCut[i] && posTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumPos[1]), signedPpos, posTrack.tpcSignal() * 50 / calibrationFactorPos->at(i), posTrack.eta()); + } + } + } + + // Lambda Selection + if (passedLambdaSelection(v0, negTrack, posTrack, collision)) { + + float ePosPr = posTrack.energy(MassProton); + float eNegPi = negTrack.energy(MassPionCharged); + + float invMass = std::sqrt((eNegPi + ePosPr) * (eNegPi + ePosPr) - ((pxNeg + pxPos) * (pxNeg + pxPos) + (pyNeg + pyPos) * (pyNeg + pyPos) + (pzNeg + pzPos) * (pzNeg + pzPos))); + + if (std::abs(invMass - MassLambda) > invMassCut) { + continue; + } + + for (int i = 0; i < kEtaIntervals; ++i) { + if (negTrack.eta() > EtaCut[i] && negTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumNeg[1]), std::abs(signedPneg), negTrack.tpcSignal() * 50 / calibrationFactorNeg->at(i), negTrack.eta()); + } + if (posTrack.eta() > EtaCut[i] && posTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumPos[2]), signedPpos, posTrack.tpcSignal() * 50 / calibrationFactorPos->at(i), posTrack.eta()); + } + } + } + + // AntiLambda Selection + if (passedAntiLambdaSelection(v0, negTrack, posTrack, collision)) { + + float ePosPi = posTrack.energy(MassPionCharged); + float eNegPr = negTrack.energy(MassProton); + + float invMass = std::sqrt((eNegPr + ePosPi) * (eNegPr + ePosPi) - ((pxNeg + pxPos) * (pxNeg + pxPos) + (pyNeg + pyPos) * (pyNeg + pyPos) + (pzNeg + pzPos) * (pzNeg + pzPos))); + + if (std::abs(invMass - MassLambda) > invMassCut) { + continue; + } + + for (int i = 0; i < kEtaIntervals; ++i) { + if (negTrack.eta() > EtaCut[i] && negTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumNeg[2]), std::abs(signedPneg), negTrack.tpcSignal() * 50 / calibrationFactorNeg->at(i), negTrack.eta()); + } + if (posTrack.eta() > EtaCut[i] && posTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumPos[1]), signedPpos, posTrack.tpcSignal() * 50 / calibrationFactorPos->at(i), posTrack.eta()); + } + } + } + + // Gamma Selection + if (passedGammaSelection(v0, negTrack, posTrack, collision)) { + + float ePosEl = posTrack.energy(MassElectron); + float eNegEl = negTrack.energy(MassElectron); + + float invMass = std::sqrt((eNegEl + ePosEl) * (eNegEl + ePosEl) - ((pxNeg + pxPos) * (pxNeg + pxPos) + (pyNeg + pyPos) * (pyNeg + pyPos) + (pzNeg + pzPos) * (pzNeg + pzPos))); + + if (std::abs(invMass - gammaMass) > invMassCutGamma) { + continue; + } + + for (int i = 0; i < kEtaIntervals; ++i) { + if (negTrack.eta() > EtaCut[i] && negTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumNeg[3]), std::abs(signedPneg), negTrack.tpcSignal() * 50 / calibrationFactorNeg->at(i), negTrack.eta()); + } + if (posTrack.eta() > EtaCut[i] && posTrack.eta() < EtaCut[i + 1]) { + registryDeDx.fill(HIST(kDedxvsMomentumPos[3]), signedPpos, posTrack.tpcSignal() * 50 / calibrationFactorPos->at(i), posTrack.eta()); + } + } + } + } + } + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From a5bcb83be84fb35873e4cd14835046e668f4b33a Mon Sep 17 00:00:00 2001 From: PaolaVT Date: Fri, 22 Aug 2025 12:46:33 -0600 Subject: [PATCH 3/7] Event selection was modified --- PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx | 47 +++++++++++--------------- 1 file changed, 20 insertions(+), 27 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx index d688f0c8e72..f6e38799dcf 100644 --- a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx +++ b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx @@ -79,7 +79,7 @@ struct DedxPidAnalysis { Configurable etaMin{"etaMin", -0.8f, "etaMin"}; Configurable etaMax{"etaMax", +0.8f, "etaMax"}; Configurable minNCrossedRowsOverFindableClustersTPC{"minNCrossedRowsOverFindableClustersTPC", 0.8f, "Additional cut on the minimum value of the ratio between crossed rows and findable clusters in the TPC"}; - Configurable maxDCAz{"maxDCAz", 2.f, "maxDCAz"}; + Configurable maxDCAz{"maxDCAz", 0.1f, "maxDCAz"}; // v0 cuts Configurable v0cospaMin{"v0cospaMin", 0.998f, "Minimum V0 CosPA"}; Configurable minimumV0Radius{"minimumV0Radius", 0.5f, @@ -201,11 +201,11 @@ struct DedxPidAnalysis { // pt vs p registryDeDx.add( - "hp_vs_pt_all_Neg", "p_vs_pT", HistType::kTH2F, - {{ptAxis}, {pAxis}}); + "heta_vs_p_vs_pt_all_Neg", "eta_vs_p_vs_pT", HistType::kTH3F, + {{etaAxis}, {ptAxis}, {pAxis}}); registryDeDx.add( - "hp_vs_pt_all_Pos", "p_vs_pT", HistType::kTH2F, - {{ptAxis}, {pAxis}}); + "heta_vs_p_vs_pt_all_Pos", "eta_vs_p_vs_pT", HistType::kTH3F, + {{etaAxis}, {ptAxis}, {pAxis}}); // De/Dx for ch and v0 particles for (int i = 0; i < kParticlesType; ++i) { @@ -596,19 +596,8 @@ struct DedxPidAnalysis { if (!collision.sel8()) return; - if (additionalCuts) { - if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) - return; - - if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) - return; - - if (std::abs(collision.posZ()) >= maxZDistanceToIP) - return; - - if (!collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) - return; - } + if (std::abs(collision.posZ()) > maxZDistanceToIP) + return; // Event Counter registryDeDx.fill(HIST("histRecVtxZData"), collision.posZ()); @@ -624,8 +613,10 @@ struct DedxPidAnalysis { continue; // phi and Ncl cut - if (!passedPhiCut(trk, magField, *fphiCutLow, *fphiCutHigh)) - continue; + if (additionalCuts) { + if (!passedPhiCut(trk, magField, *fphiCutLow, *fphiCutHigh)) + continue; + } float signedP = trk.sign() * trk.tpcInnerParam(); @@ -704,10 +695,10 @@ struct DedxPidAnalysis { if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { if (signedP > 0) { registryDeDx.fill(HIST(kDedxvsMomentumPos[0]), signedP, trk.tpcSignal() * 50 / calibrationFactorPos->at(i), trk.eta()); - registryDeDx.fill(HIST("hp_vs_pt_all_Pos"), trk.pt(), signedP); + registryDeDx.fill(HIST("heta_vs_p_vs_pt_all_Pos"), trk.eta(), trk.pt(), signedP); } else { registryDeDx.fill(HIST(kDedxvsMomentumNeg[0]), std::abs(signedP), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i), trk.eta()); - registryDeDx.fill(HIST("hp_vs_pt_all_Neg"), trk.pt(), std::abs(signedP)); + registryDeDx.fill(HIST("heta_vs_p_vs_pt_all_Neg"), trk.eta(), trk.pt(), std::abs(signedP)); } } } @@ -736,11 +727,13 @@ struct DedxPidAnalysis { if (!negTrack.passedTPCRefit()) continue; // phi and Ncl cut - if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) - continue; - - if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) - continue; + if (additionalCuts) { + if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; + + if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; + } float signedPpos = posTrack.sign() * posTrack.tpcInnerParam(); float signedPneg = negTrack.sign() * negTrack.tpcInnerParam(); From 3ca59ecc4d7934e3e7728faf82ab80e731e700eb Mon Sep 17 00:00:00 2001 From: PaolaVT Date: Fri, 22 Aug 2025 13:01:22 -0600 Subject: [PATCH 4/7] Event selection was modified --- PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx index f6e38799dcf..2d042bd5e96 100644 --- a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx +++ b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx @@ -613,10 +613,10 @@ struct DedxPidAnalysis { continue; // phi and Ncl cut - if (additionalCuts) { - if (!passedPhiCut(trk, magField, *fphiCutLow, *fphiCutHigh)) - continue; - } + if (additionalCuts) { + if (!passedPhiCut(trk, magField, *fphiCutLow, *fphiCutHigh)) + continue; + } float signedP = trk.sign() * trk.tpcInnerParam(); @@ -727,13 +727,13 @@ struct DedxPidAnalysis { if (!negTrack.passedTPCRefit()) continue; // phi and Ncl cut - if (additionalCuts) { - if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) - continue; - - if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) - continue; - } + if (additionalCuts) { + if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; + + if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; + } float signedPpos = posTrack.sign() * posTrack.tpcInnerParam(); float signedPneg = negTrack.sign() * negTrack.tpcInnerParam(); From 55663dd91eb54c53d02c74f2ebde0d3088f425a4 Mon Sep 17 00:00:00 2001 From: PaolaVT Date: Thu, 4 Sep 2025 00:41:43 -0600 Subject: [PATCH 5/7] New cuts and some modifications on their names were implemented --- PWGMM/UE/Tasks/dedxAnalysis.cxx | 532 +++++++++++++++++++++++++------- 1 file changed, 427 insertions(+), 105 deletions(-) diff --git a/PWGMM/UE/Tasks/dedxAnalysis.cxx b/PWGMM/UE/Tasks/dedxAnalysis.cxx index 11aea4031be..faaf9cca459 100644 --- a/PWGMM/UE/Tasks/dedxAnalysis.cxx +++ b/PWGMM/UE/Tasks/dedxAnalysis.cxx @@ -25,11 +25,18 @@ #include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/TrackSelectionTables.h" +#include "CCDB/BasicCCDBManager.h" +#include "CCDB/CcdbApi.h" +#include "CommonConstants/PhysicsConstants.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "Framework/ASoA.h" #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" +#include "Framework/Logger.h" #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/Track.h" +#include "ReconstructionDataFormats/V0.h" #include "TF1.h" @@ -42,6 +49,7 @@ using PIDTracks = soa::Join< aod::pidTOFFullPi, aod::pidTOFFullPr, aod::pidTOFFullEl, aod::pidTOFbeta>; using SelectedCollisions = soa::Join; +using BCsRun3 = soa::Join; struct DedxAnalysis { @@ -62,13 +70,47 @@ struct DedxAnalysis { float pionTofCut = 1.0; float invMassCut = 0.01; float invMassCutGamma = 0.0015; - float magField = 1; float pTcut = 2.0; + // Event cut labels + enum EvCutLabel { + AllEv = 1, + SelEigth, + ZVtxCut + }; + + // Track primary label + enum TrkPriCutLabel { + AllPri = 1, + SelectionPrim, + PhiVarCutPri, + NTPCClCutPri, + NITSClCutPri + }; + + // Track secondary lebel + enum TrkSecCutLabel { + AllSec = 1, + V0CosPA, + V0DecayRadius, + V0Daughters, + TPCRefit, + PhiVarCutSec, + NTPCClCutSec, + NITSClCutSec, + V0RapidityK0s, + V0ProperLifetimeK0s, + V0RapidityLambda, + V0ProperLifetimeLambda, + V0RapidityAntiLambda, + V0ProperLifetimeAntiLambda + }; // Configurable Parameters // Tracks cuts Configurable minTPCnClsFound{"minTPCnClsFound", 70.0f, "min number of found TPC clusters"}; + Configurable minITSnCls{"minITSnCls", 70.0f, + "min number of ITS clusters"}; Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of found TPC crossed rows"}; Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; @@ -79,7 +121,7 @@ struct DedxAnalysis { Configurable etaMin{"etaMin", -0.8f, "etaMin"}; Configurable etaMax{"etaMax", +0.8f, "etaMax"}; Configurable minNCrossedRowsOverFindableClustersTPC{"minNCrossedRowsOverFindableClustersTPC", 0.8f, "Additional cut on the minimum value of the ratio between crossed rows and findable clusters in the TPC"}; - Configurable maxDCAz{"maxDCAz", 2.f, "maxDCAz"}; + Configurable maxDCAz{"maxDCAz", 0.1f, "maxDCAz"}; // v0 cuts Configurable v0cospaMin{"v0cospaMin", 0.998f, "Minimum V0 CosPA"}; Configurable minimumV0Radius{"minimumV0Radius", 0.5f, @@ -88,6 +130,9 @@ struct DedxAnalysis { "Maximum V0 Radius"}; Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 0.5f, "Maximum DCA Daughters"}; + Configurable v0rapidityCut{"v0rapidityCut", 0.5f, "V0 rapidity cut"}; + Configurable v0ProperLifetimeCutK0s{"v0ProperLifetimeCutK0s", 20.f, "V0 proper lifetime cut for K0s"}; + Configurable v0ProperLifetimeCutLambda{"v0ProperLifetimeCutLambda", 30.f, "V0 proper lifetime cut for Lambda"}; Configurable nsigmaTOFmax{"nsigmaTOFmax", 3.0f, "Maximum nsigma TOF"}; Configurable minMassK0s{"minMassK0s", 0.4f, "Minimum Mass K0s"}; Configurable maxMassK0s{"maxMassK0s", 0.6f, "Maximum Mass K0s"}; @@ -99,17 +144,23 @@ struct DedxAnalysis { "Minimum Mass Gamma"}; Configurable maxMassGamma{"maxMassGamma", 0.002022f, "Maximum Mass Gamma"}; - Configurable nclCut{"nclCut", 135.0f, - "ncl Cut"}; Configurable calibrationMode{"calibrationMode", false, "calibration mode"}; - Configurable additionalCuts{"additionalCuts", true, "additional cuts"}; + Configurable phiVarCut{"phiVarCut", true, "phi var cut"}; + Configurable nTPCClCut{"nTPCClCut", true, "number of clusters in TPC cut"}; + Configurable nITSClCut{"nITSClCut", true, "number of clusters in ITS cut"}; // Histograms names static constexpr std::string_view kDedxvsMomentumPos[kParticlesType] = {"dEdx_vs_Momentum_all_Pos", "dEdx_vs_Momentum_Pi_v0_Pos", "dEdx_vs_Momentum_Pr_v0_Pos", "dEdx_vs_Momentum_El_v0_Pos"}; static constexpr std::string_view kDedxvsMomentumNeg[kParticlesType] = {"dEdx_vs_Momentum_all_Neg", "dEdx_vs_Momentum_Pi_v0_Neg", "dEdx_vs_Momentum_Pr_v0_Neg", "dEdx_vs_Momentum_El_v0_Neg"}; - static constexpr std::string_view kNclDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_8_Before"}; - static constexpr std::string_view kNclDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_8_Before"}; - static constexpr std::string_view kNclDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_vs_dEdx_vs_Momentum_Neg_8_After"}; - static constexpr std::string_view kNclDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_vs_dEdx_vs_Momentum_Pos_8_After"}; + // Ncl TPC + static constexpr std::string_view kNclTPCDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_8_Before"}; + static constexpr std::string_view kNclTPCDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_8_Before"}; + static constexpr std::string_view kNclTPCDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_8_After"}; + static constexpr std::string_view kNclTPCDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_8_After"}; + // Ncl TPC + static constexpr std::string_view kNclITSDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_8_Before"}; + static constexpr std::string_view kNclITSDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_8_Before"}; + static constexpr std::string_view kNclITSDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_8_After"}; + static constexpr std::string_view kNclITSDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_8_After"}; static constexpr double EtaCut[kEtaIntervals + 1] = {-0.8, -0.6, -0.4, -0.2, 0.0, 0.2, 0.4, 0.6, 0.8}; Configurable> calibrationFactorNeg{"calibrationFactorNeg", {50.4011, 50.4764, 50.186, 49.2955, 48.8222, 49.4273, 49.9292, 50.0556}, "negative calibration factors"}; Configurable> calibrationFactorPos{"calibrationFactorPos", {50.5157, 50.6359, 50.3198, 49.3345, 48.9197, 49.4931, 50.0188, 50.1406}, "positive calibration factors"}; @@ -118,6 +169,7 @@ struct DedxAnalysis { // phi cut fits TF1* fphiCutHigh = nullptr; TF1* fphiCutLow = nullptr; + Service ccdb; TrackSelection myTrackSelection() { @@ -129,7 +181,7 @@ struct DedxAnalysis { selectedTracks.SetMinNCrossedRowsTPC(minNCrossedRowsTPC); selectedTracks.SetMinNCrossedRowsOverFindableClustersTPC(minNCrossedRowsOverFindableClustersTPC); selectedTracks.SetMaxChi2PerClusterTPC(maxChi2TPC); - selectedTracks.SetRequireHitsInITSLayers(1, {0, 1}); + selectedTracks.SetRequireHitsInITSLayers(1, {0, 1, 2}); selectedTracks.SetMaxChi2PerClusterITS(maxChi2ITS); selectedTracks.SetMaxDcaXYPtDep([](float pt) { return 0.0105f + 0.0350f / std::pow(pt, 1.1f); }); selectedTracks.SetMaxDcaZ(maxDCAz); @@ -201,11 +253,11 @@ struct DedxAnalysis { // pt vs p registryDeDx.add( - "hp_vs_pt_all_Neg", "p_vs_pT", HistType::kTH2F, - {{ptAxis}, {pAxis}}); + "heta_vs_p_vs_pt_all_Neg", "eta_vs_p_vs_pT", HistType::kTH3F, + {{etaAxis}, {ptAxis}, {pAxis}}); registryDeDx.add( - "hp_vs_pt_all_Pos", "p_vs_pT", HistType::kTH2F, - {{ptAxis}, {pAxis}}); + "heta_vs_p_vs_pt_all_Pos", "eta_vs_p_vs_pT", HistType::kTH3F, + {{etaAxis}, {ptAxis}, {pAxis}}); // De/Dx for ch and v0 particles for (int i = 0; i < kParticlesType; ++i) { @@ -219,28 +271,45 @@ struct DedxAnalysis { registryDeDx.add( "hdEdx_vs_phi", "dE/dx", HistType::kTH2F, {{100, 0.0, 6.4, "#phi"}, {dedxAxis}}); - // phi cut - registryDeDx.add( - "hpt_vs_phi_Ncl_After", "phi cut", HistType::kTH3F, - {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); - - registryDeDx.add( - "hpt_vs_phi_Ncl_Before", "phi cut", HistType::kTH3F, - {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); - - // Ncl vs de/dx + if (phiVarCut) { + registryDeDx.add( + "hpt_vs_phi_Ncl_TPC_After", "phi cut", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); - for (int i = 0; i < kEtaIntervals; ++i) { - registryDeDx.add(kNclDedxMomentumPosBefore[i].data(), "Ncl vs dE/dx vs Momentum Positive before", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); - registryDeDx.add(kNclDedxMomentumNegBefore[i].data(), "Ncl vs dE/dx vs Momentum Negative before", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add( + "hpt_vs_phi_Ncl_TPC_Before", "phi cut", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); + + // Ncl vs de/dx TPC + + for (int i = 0; i < kEtaIntervals; ++i) { + registryDeDx.add(kNclTPCDedxMomentumPosBefore[i].data(), "Ncl TPC vs dE/dx vs Momentum Positive before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclTPCDedxMomentumNegBefore[i].data(), "Ncl TPC vs dE/dx vs Momentum Negative before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + if (nTPCClCut) { + registryDeDx.add(kNclTPCDedxMomentumPosAfter[i].data(), "Ncl TPC vs dE/dx vs Momentum Positive after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclTPCDedxMomentumNegAfter[i].data(), "Ncl TPC vs dE/dx vs Momentum Negative after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + } + } + } - registryDeDx.add(kNclDedxMomentumPosAfter[i].data(), "Ncl vs dE/dx vs Momentum Positive after", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); - registryDeDx.add(kNclDedxMomentumNegAfter[i].data(), "Ncl vs dE/dx vs Momentum Negative after", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + // Ncl vs de/dx ITS + if (nITSClCut) { + for (int i = 0; i < kEtaIntervals; ++i) { + registryDeDx.add(kNclITSDedxMomentumPosBefore[i].data(), "Ncl ITS vs dE/dx vs Momentum Positive before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclITSDedxMomentumNegBefore[i].data(), "Ncl ITS vs dE/dx vs Momentum Negative before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + + registryDeDx.add(kNclITSDedxMomentumPosAfter[i].data(), "Ncl ITS vs dE/dx vs Momentum Positive after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclITSDedxMomentumNegAfter[i].data(), "Ncl ITS vs dE/dx vs Momentum Negative after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + } } // beta plot @@ -255,6 +324,42 @@ struct DedxAnalysis { // Event Counter registryDeDx.add("histRecVtxZData", "collision z position", HistType::kTH1F, {{100, -20.0, +20.0, "z_{vtx} (cm)"}}); + // Event Counter + registryDeDx.add("evsel", "events selected", HistType::kTH1F, {{3, 0.5, 3.5, ""}}); + auto hstat = registryDeDx.get(HIST("evsel")); + auto* x = hstat->GetXaxis(); + x->SetBinLabel(1, "AllEv"); + x->SetBinLabel(2, "SelEigth"); + x->SetBinLabel(3, "ZVtxCut"); + + // Track Counter + registryDeDx.add("trackselAll", "track selected all particles", HistType::kTH1F, {{5, 0.5, 5.5, ""}}); + auto htrackAll = registryDeDx.get(HIST("trackselAll")); + auto* xAll = htrackAll->GetXaxis(); + xAll->SetBinLabel(1, "AllPri"); + xAll->SetBinLabel(2, "SelectionPrim"); + xAll->SetBinLabel(3, "PhiVarCutPri"); + xAll->SetBinLabel(4, "NTPCClCutPri"); + xAll->SetBinLabel(5, "NITSClCutPri"); + + registryDeDx.add("trackselSec", "track selected sec particles", HistType::kTH1F, {{13, 0.5, 13.5, ""}}); + auto htrackSec = registryDeDx.get(HIST("trackselSec")); + auto* xSec = htrackSec->GetXaxis(); + xSec->SetBinLabel(1, "AllSec"); + xSec->SetBinLabel(2, "V0CosPA"); + xSec->SetBinLabel(3, "V0DecayRadius"); + xSec->SetBinLabel(4, "V0Daughters"); + xSec->SetBinLabel(5, "TPCRefit"); + xSec->SetBinLabel(6, "PhiVarCutSec"); + xSec->SetBinLabel(7, "NTPCClCutSec"); + xSec->SetBinLabel(8, "NITSClCutSec"); + xSec->SetBinLabel(9, "V0RapidityK0s"); + xSec->SetBinLabel(10, "V0ProperLifetimeK0s"); + xSec->SetBinLabel(11, "V0RapidityLambda"); + xSec->SetBinLabel(12, "V0ProperLifetimeLambda"); + xSec->SetBinLabel(13, "V0RapidityAntiLambda"); + xSec->SetBinLabel(14, "V0ProperLifetimeAntiLambda"); + mySelectionPrim = myTrackSelection(); } @@ -265,8 +370,6 @@ struct DedxAnalysis { // Single-Track Selections if (!track.hasTPC()) return false; - if (track.tpcNClsFound() < minTPCnClsFound) - return false; if (track.tpcNClsCrossedRows() < minNCrossedRowsTPC) return false; if (track.tpcChi2NCl() > maxChi2TPC) @@ -283,8 +386,15 @@ struct DedxAnalysis { { if (v0.v0cosPA() < v0cospaMin) return false; + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0CosPA); + if (v0.v0radius() < minimumV0Radius || v0.v0radius() > maximumV0Radius) return false; + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0DecayRadius); + + if (v0.dcaV0daughters() > dcaV0DaughtersMax) + return false; + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0Daughters); return true; } @@ -417,17 +527,31 @@ struct DedxAnalysis { return true; } + // Magnetic field + int getMagneticField(uint64_t timestamp) + { + static o2::parameters::GRPMagField* grpo = nullptr; + if (grpo == nullptr) { + grpo = ccdb->getForTimeStamp("GLO/Config/GRPMagField", timestamp); + if (grpo == nullptr) { + LOGF(fatal, "GRP object not found for timestamp %llu", timestamp); + return 0; + } + LOGF(info, "Retrieved GRP for timestamp %llu with magnetic field of %d kG", timestamp, grpo->getNominalL3Field()); + } + return grpo->getNominalL3Field(); + } // Phi cut template - bool passedPhiCut(const T& trk, float magField, const TF1& fphiCutLow, const TF1& fphiCutHigh) + bool passedPhiVarCut(const T& trk, float magField, const TF1& fphiCutLow, const TF1& fphiCutHigh) { float pt = trk.pt(); float phi = trk.phi(); int charge = trk.sign(); float eta = trk.eta(); - auto nTPCCl = trk.tpcNClsFindable() - trk.tpcNClsFindableMinusFound(); float sigP = trk.sign() * trk.tpcInnerParam(); + auto nTPCCl = trk.tpcNClsFound(); if (pt < pTcut) return true; @@ -441,7 +565,7 @@ struct DedxAnalysis { phi += o2::constants::math::PI / 18.0f; phi = std::fmod(phi, o2::constants::math::PI / 9.0f); - registryDeDx.fill(HIST("hpt_vs_phi_Ncl_Before"), pt, phi, nTPCCl); + registryDeDx.fill(HIST("hpt_vs_phi_Ncl_TPC_Before"), pt, phi, nTPCCl); // cut phi if (phi < fphiCutHigh.Eval(pt) && phi > fphiCutLow.Eval(pt)) @@ -449,107 +573,224 @@ struct DedxAnalysis { if (eta > EtaCut[0] && eta < EtaCut[1]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[0]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[0]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[1] && eta < EtaCut[2]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[1]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[1]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[2] && eta < EtaCut[3]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[2]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[2]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[3] && eta < EtaCut[4]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[3]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[3]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[4] && eta < EtaCut[5]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[4]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[4]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[5] && eta < EtaCut[6]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[5]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[5]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[6] && eta < EtaCut[7]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[6]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[6]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[7]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[7]), nTPCCl, trk.tpcSignal(), sigP); } } + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::PhiVarCutPri); - // cut Ncl - if (nTPCCl < nclCut) - return false; + if (nTPCClCut) { + // cut Ncl + if (nTPCCl < minTPCnClsFound) + return false; - registryDeDx.fill(HIST("hpt_vs_phi_Ncl_After"), pt, phi, nTPCCl); + registryDeDx.fill(HIST("hpt_vs_phi_Ncl_TPC_After"), pt, phi, nTPCCl); + + if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[0]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[1]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[2]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[3]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[4]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[5]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[6]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[7]), nTPCCl, trk.tpcSignal(), sigP); + } + } + } + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NTPCClCutPri); + return true; + } + + // NclCutITS + template + bool passedNITSClCut(const T& trk) + { + float eta = trk.eta(); + float sigP = trk.sign() * trk.tpcInnerParam(); + auto nITSCl = trk.itsNCls(); if (eta > EtaCut[0] && eta < EtaCut[1]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[0]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[0]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[0]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[1] && eta < EtaCut[2]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[1]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[1]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[1]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[2] && eta < EtaCut[3]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[2]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[2]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[2]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[3] && eta < EtaCut[4]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[3]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[3]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[3]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[4] && eta < EtaCut[5]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[4]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[4]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[4]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[5] && eta < EtaCut[6]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[5]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[5]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[5]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[6] && eta < EtaCut[7]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[6]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[6]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[6]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[7]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[7]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[7]), nITSCl, trk.tpcSignal(), sigP); + } + } + + if (nITSCl < minITSnCls) + return false; + + if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[0]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[0]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[1]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[1]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[2]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[2]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[3]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[3]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[4]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[4]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[5]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[5]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[6]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[6]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[7]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[7]), nITSCl, trk.tpcSignal(), sigP); } } @@ -563,7 +804,6 @@ struct DedxAnalysis { float pt = trk.pt(); float phi = trk.phi(); int charge = trk.sign(); - auto nTPCCl = trk.tpcNClsFindable() - trk.tpcNClsFindableMinusFound(); if (pt < pTcut) return true; @@ -581,8 +821,28 @@ struct DedxAnalysis { if (phi < fphiCutHigh.Eval(pt) && phi > fphiCutLow.Eval(pt)) return false; // reject track - // cut Ncl - if (nTPCCl < nclCut) + return true; + } + + // NclCutTPC + template + bool passedNTPCClCutSecondaries(const T& trk) + { + auto nTPCCl = trk.tpcNClsFound(); + + if (nTPCCl < minTPCnClsFound) + return false; + + return true; + } + + // NclCutITS primary + template + bool passedNITSClCutSecondaries(const T& trk) + { + auto nITSCl = trk.itsNCls(); + + if (nITSCl < minITSnCls) return false; return true; @@ -592,40 +852,46 @@ struct DedxAnalysis { void process(SelectedCollisions::iterator const& collision, aod::V0Datas const& fullV0s, PIDTracks const& tracks) { + registryDeDx.fill(HIST("evsel"), EvCutLabel::AllEv); // Event Selection if (!collision.sel8()) return; - if (additionalCuts) { - if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) - return; + registryDeDx.fill(HIST("evsel"), EvCutLabel::SelEigth); - if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) - return; - - if (std::abs(collision.posZ()) >= maxZDistanceToIP) - return; + if (std::abs(collision.posZ()) > maxZDistanceToIP) + return; - if (!collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) - return; - } + registryDeDx.fill(HIST("evsel"), EvCutLabel::ZVtxCut); // Event Counter registryDeDx.fill(HIST("histRecVtxZData"), collision.posZ()); - // Kaons - for (const auto& trk : tracks) { + // For magnetic field + const auto& foundBC = collision.foundBC_as(); + const uint64_t timeStamp{foundBC.timestamp()}; + const int magField{getMagneticField(timeStamp)}; + for (const auto& trk : tracks) { + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::AllPri); // track Selection - if (!passedSingleTrackSelection(trk, collision)) - continue; - if (!mySelectionPrim.IsSelected(trk)) continue; + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::SelectionPrim); + // phi and Ncl cut - if (!passedPhiCut(trk, magField, *fphiCutLow, *fphiCutHigh)) - continue; + if (phiVarCut) { + if (!passedPhiVarCut(trk, magField, *fphiCutLow, *fphiCutHigh)) + continue; + } + + // NCl cut ITS + if (nITSClCut) { + if (!passedNITSClCut(trk)) + continue; + } + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NITSClCutPri); float signedP = trk.sign() * trk.tpcInnerParam(); @@ -704,10 +970,10 @@ struct DedxAnalysis { if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { if (signedP > 0) { registryDeDx.fill(HIST(kDedxvsMomentumPos[0]), signedP, trk.tpcSignal() * 50 / calibrationFactorPos->at(i), trk.eta()); - registryDeDx.fill(HIST("hp_vs_pt_all_Pos"), trk.pt(), signedP); + registryDeDx.fill(HIST("heta_vs_p_vs_pt_all_Pos"), trk.eta(), trk.pt(), signedP); } else { registryDeDx.fill(HIST(kDedxvsMomentumNeg[0]), std::abs(signedP), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i), trk.eta()); - registryDeDx.fill(HIST("hp_vs_pt_all_Neg"), trk.pt(), std::abs(signedP)); + registryDeDx.fill(HIST("heta_vs_p_vs_pt_all_Neg"), trk.eta(), trk.pt(), std::abs(signedP)); } } } @@ -719,14 +985,11 @@ struct DedxAnalysis { for (const auto& v0 : fullV0s) { // Standard V0 Selections + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllSec); if (!passedV0Selection(v0, collision)) { continue; } - if (v0.dcaV0daughters() > dcaV0DaughtersMax) { - continue; - } - // Positive and Negative Tracks const auto& posTrack = v0.posTrack_as(); const auto& negTrack = v0.negTrack_as(); @@ -735,12 +998,37 @@ struct DedxAnalysis { continue; if (!negTrack.passedTPCRefit()) continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::TPCRefit); // phi and Ncl cut - if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) - continue; + if (phiVarCut) { + if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; - if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) - continue; + if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) + continue; + } + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::PhiVarCutSec); + + if (nTPCClCut) { + if (!passedNTPCClCutSecondaries(posTrack)) + continue; + + if (!passedNTPCClCutSecondaries(negTrack)) + continue; + } + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NTPCClCutSec); + + if (nITSClCut) { + if (!passedNITSClCutSecondaries(posTrack)) + continue; + + if (!passedNITSClCutSecondaries(negTrack)) + continue; + } + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NITSClCutSec); float signedPpos = posTrack.sign() * posTrack.tpcInnerParam(); float signedPneg = negTrack.sign() * negTrack.tpcInnerParam(); @@ -757,6 +1045,18 @@ struct DedxAnalysis { // K0s Selection if (passedK0Selection(v0, negTrack, posTrack, collision)) { + + if (std::abs(v0.rapidity(MassK0Short)) > v0rapidityCut) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityK0s); + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassK0Short; + + if (properLifetime > v0ProperLifetimeCutK0s) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeK0s); + float ePosPi = posTrack.energy(MassPionCharged); float eNegPi = negTrack.energy(MassPionCharged); @@ -779,6 +1079,17 @@ struct DedxAnalysis { // Lambda Selection if (passedLambdaSelection(v0, negTrack, posTrack, collision)) { + if (std::abs(v0.rapidity(MassLambda)) > v0rapidityCut) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityLambda); + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassLambda; + + if (properLifetime > v0ProperLifetimeCutLambda) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeLambda); + float ePosPr = posTrack.energy(MassProton); float eNegPi = negTrack.energy(MassPionCharged); @@ -801,6 +1112,17 @@ struct DedxAnalysis { // AntiLambda Selection if (passedAntiLambdaSelection(v0, negTrack, posTrack, collision)) { + if (std::abs(v0.rapidity(MassLambda)) > v0rapidityCut) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityAntiLambda); + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassLambda; + + if (properLifetime > v0ProperLifetimeCutLambda) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeAntiLambda); + float ePosPi = posTrack.energy(MassPionCharged); float eNegPr = negTrack.energy(MassProton); From d97f118583f907fd4a6a0f14b25c085738584220 Mon Sep 17 00:00:00 2001 From: Paola Vargas Torres Date: Thu, 11 Sep 2025 15:48:16 -0600 Subject: [PATCH 6/7] New histograms, event and track seleccions were implemented --- PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx | 639 +++++++++++++++++++++---- 1 file changed, 544 insertions(+), 95 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx index 2d042bd5e96..851d1634b68 100644 --- a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx +++ b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx @@ -25,9 +25,13 @@ #include "Common/DataModel/PIDResponse.h" #include "Common/DataModel/TrackSelectionTables.h" +#include "CCDB/BasicCCDBManager.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "Framework/ASoA.h" #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" +#include "Framework/Logger.h" #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/Track.h" @@ -35,13 +39,15 @@ using namespace o2; using namespace o2::framework; +using namespace o2::framework::expressions; using namespace constants::physics; using PIDTracks = soa::Join< aod::Tracks, aod::TracksExtra, aod::TrackSelectionExtension, aod::TracksDCA, aod::TrackSelection, - aod::pidTOFFullPi, aod::pidTOFFullPr, aod::pidTOFFullEl, aod::pidTOFbeta>; + aod::pidTOFFullPi, aod::pidTOFFullPr, aod::pidTOFFullEl, aod::pidTOFbeta, aod::pidTPCPi, aod::pidTPCPr, aod::pidTPCEl>; using SelectedCollisions = soa::Join; +using BCsRun3 = soa::Join; struct DedxPidAnalysis { @@ -62,13 +68,54 @@ struct DedxPidAnalysis { float pionTofCut = 1.0; float invMassCut = 0.01; float invMassCutGamma = 0.0015; - float magField = 1; float pTcut = 2.0; + // Event cut labels + enum EvCutLabel { + AllEv = 1, + SelEigth, + ZVtxCut, + NoSameBunchPileup, + GoodZvtxFT0vsPV + + }; + + // Track primary label + enum TrkPriCutLabel { + AllPri = 1, + SelectionPrim, + PhiVarCutPri, + NTPCClCutPri, + NITSClCutPri + }; + + // Track secondary lebel + enum TrkSecCutLabel { + AllSec = 1, + V0CosPA, + V0DecayRadius, + V0Daughters, + TPCRefit, + PhiVarCutSec, + NTPCClCutSec, + NITSClCutSec, + AllK0s, + V0RapidityK0s, + V0ProperLifetimeK0s, + AllLambda, + V0RapidityLambda, + V0ProperLifetimeLambda, + AllAntiLambda, + V0RapidityAntiLambda, + V0ProperLifetimeAntiLambda, + AllGamma + }; // Configurable Parameters // Tracks cuts - Configurable minTPCnClsFound{"minTPCnClsFound", 70.0f, + Configurable minTPCnClsFound{"minTPCnClsFound", 135.0f, "min number of found TPC clusters"}; + Configurable minITSnCls{"minITSnCls", 0.0f, + "min number of ITS clusters"}; Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of found TPC crossed rows"}; Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; @@ -88,6 +135,9 @@ struct DedxPidAnalysis { "Maximum V0 Radius"}; Configurable dcaV0DaughtersMax{"dcaV0DaughtersMax", 0.5f, "Maximum DCA Daughters"}; + Configurable v0rapidityCut{"v0rapidityCut", 0.5f, "V0 rapidity cut"}; + Configurable v0ProperLifetimeCutK0s{"v0ProperLifetimeCutK0s", 20.f, "V0 proper lifetime cut for K0s"}; + Configurable v0ProperLifetimeCutLambda{"v0ProperLifetimeCutLambda", 30.f, "V0 proper lifetime cut for Lambda"}; Configurable nsigmaTOFmax{"nsigmaTOFmax", 3.0f, "Maximum nsigma TOF"}; Configurable minMassK0s{"minMassK0s", 0.4f, "Minimum Mass K0s"}; Configurable maxMassK0s{"maxMassK0s", 0.6f, "Maximum Mass K0s"}; @@ -99,17 +149,24 @@ struct DedxPidAnalysis { "Minimum Mass Gamma"}; Configurable maxMassGamma{"maxMassGamma", 0.002022f, "Maximum Mass Gamma"}; - Configurable nclCut{"nclCut", 135.0f, - "ncl Cut"}; Configurable calibrationMode{"calibrationMode", false, "calibration mode"}; - Configurable additionalCuts{"additionalCuts", true, "additional cuts"}; + Configurable phiVarCut{"phiVarCut", true, "phi var cut"}; + Configurable nTPCClCut{"nTPCClCut", true, "number of clusters in TPC cut"}; + Configurable nITSClCut{"nITSClCut", true, "number of clusters in ITS cut"}; + Configurable V0SelectionMode{"V0SelectionMode", 1, "V0 Selection base on TPC: 1, TOF:2 ,Both:3"}; // Histograms names static constexpr std::string_view kDedxvsMomentumPos[kParticlesType] = {"dEdx_vs_Momentum_all_Pos", "dEdx_vs_Momentum_Pi_v0_Pos", "dEdx_vs_Momentum_Pr_v0_Pos", "dEdx_vs_Momentum_El_v0_Pos"}; static constexpr std::string_view kDedxvsMomentumNeg[kParticlesType] = {"dEdx_vs_Momentum_all_Neg", "dEdx_vs_Momentum_Pi_v0_Neg", "dEdx_vs_Momentum_Pr_v0_Neg", "dEdx_vs_Momentum_El_v0_Neg"}; - static constexpr std::string_view kNclDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_vs_dEdx_vs_Momentum_Neg_8_Before"}; - static constexpr std::string_view kNclDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_vs_dEdx_vs_Momentum_Pos_8_Before"}; - static constexpr std::string_view kNclDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_vs_dEdx_vs_Momentum_Neg_8_After"}; - static constexpr std::string_view kNclDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_vs_dEdx_vs_Momentum_Pos_8_After"}; + // Ncl TPC + static constexpr std::string_view kNclTPCDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_8_Before"}; + static constexpr std::string_view kNclTPCDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_8_Before"}; + static constexpr std::string_view kNclTPCDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Neg_8_After"}; + static constexpr std::string_view kNclTPCDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_TPC_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_TPC_vs_dEdx_vs_Momentum_Pos_8_After"}; + // Ncl TPC + static constexpr std::string_view kNclITSDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_8_Before"}; + static constexpr std::string_view kNclITSDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_8_Before"}; + static constexpr std::string_view kNclITSDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Neg_8_After"}; + static constexpr std::string_view kNclITSDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_ITS_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_ITS_vs_dEdx_vs_Momentum_Pos_8_After"}; static constexpr double EtaCut[kEtaIntervals + 1] = {-0.8, -0.6, -0.4, -0.2, 0.0, 0.2, 0.4, 0.6, 0.8}; Configurable> calibrationFactorNeg{"calibrationFactorNeg", {50.4011, 50.4764, 50.186, 49.2955, 48.8222, 49.4273, 49.9292, 50.0556}, "negative calibration factors"}; Configurable> calibrationFactorPos{"calibrationFactorPos", {50.5157, 50.6359, 50.3198, 49.3345, 48.9197, 49.4931, 50.0188, 50.1406}, "positive calibration factors"}; @@ -118,6 +175,7 @@ struct DedxPidAnalysis { // phi cut fits TF1* fphiCutHigh = nullptr; TF1* fphiCutLow = nullptr; + Service ccdb; TrackSelection myTrackSelection() { @@ -129,7 +187,7 @@ struct DedxPidAnalysis { selectedTracks.SetMinNCrossedRowsTPC(minNCrossedRowsTPC); selectedTracks.SetMinNCrossedRowsOverFindableClustersTPC(minNCrossedRowsOverFindableClustersTPC); selectedTracks.SetMaxChi2PerClusterTPC(maxChi2TPC); - selectedTracks.SetRequireHitsInITSLayers(1, {0, 1}); + selectedTracks.SetRequireHitsInITSLayers(1, {0, 1, 2}); selectedTracks.SetMaxChi2PerClusterITS(maxChi2ITS); selectedTracks.SetMaxDcaXYPtDep([](float pt) { return 0.0105f + 0.0350f / std::pow(pt, 1.1f); }); selectedTracks.SetMaxDcaZ(maxDCAz); @@ -142,6 +200,14 @@ struct DedxPidAnalysis { void init(InitContext const&) { + if (V0SelectionMode == 1) { + LOGF(info, "V0 seleccion using TPC only"); + } else if (V0SelectionMode == 2) { + LOGF(info, "V0 seleccion using TOF only"); + } else if (V0SelectionMode == 3) { + LOGF(info, "V0 seleccion using TOF + TPC"); + } + AxisSpec dedxAxis{100, 0.0, 100.0, "dE/dx (a. u.)"}; AxisSpec ptAxis = {binP, "pT (GeV/c)"}; AxisSpec etaAxis{8, -0.8, 0.8, "#eta"}; @@ -219,28 +285,61 @@ struct DedxPidAnalysis { registryDeDx.add( "hdEdx_vs_phi", "dE/dx", HistType::kTH2F, {{100, 0.0, 6.4, "#phi"}, {dedxAxis}}); - // phi cut - registryDeDx.add( - "hpt_vs_phi_Ncl_After", "phi cut", HistType::kTH3F, - {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); + if (phiVarCut) { + // pt + registryDeDx.add( + "hpt_vs_phi_Ncl_TPC_After", "phi cut vs pt", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); - registryDeDx.add( - "hpt_vs_phi_Ncl_Before", "phi cut", HistType::kTH3F, - {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); + registryDeDx.add( + "hpt_vs_phi_Ncl_TPC_Before", "phi cut vs pt", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); + // p + registryDeDx.add( + "hp_vs_phi_Ncl_TPC_After", "phi cut vs p", HistType::kTH3F, + {{pAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); - // Ncl vs de/dx + registryDeDx.add( + "hp_vs_phi_Ncl_TPC_Before", "phi cut vs p", HistType::kTH3F, + {{pAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl}"}}); + // eta + registryDeDx.add( + "heta_vs_Ncl_TPC_Before", "eta and N_{cl}", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl}"}}); - for (int i = 0; i < kEtaIntervals; ++i) { - registryDeDx.add(kNclDedxMomentumPosBefore[i].data(), "Ncl vs dE/dx vs Momentum Positive before", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); - registryDeDx.add(kNclDedxMomentumNegBefore[i].data(), "Ncl vs dE/dx vs Momentum Negative before", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add( + "heta_vs_Ncl_TPC_After", "eta and N_{cl} ", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl}"}}); + } + // Ncl vs de/dx TPC + if (nTPCClCut) { + for (int i = 0; i < kEtaIntervals; ++i) { + registryDeDx.add(kNclTPCDedxMomentumPosBefore[i].data(), "Ncl TPC vs dE/dx vs Momentum Positive before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclTPCDedxMomentumNegBefore[i].data(), "Ncl TPC vs dE/dx vs Momentum Negative before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + + registryDeDx.add(kNclTPCDedxMomentumPosAfter[i].data(), "Ncl TPC vs dE/dx vs Momentum Positive after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclTPCDedxMomentumNegAfter[i].data(), "Ncl TPC vs dE/dx vs Momentum Negative after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{TPC}"}, {dedxAxis}, {pAxis}}); + } + } - registryDeDx.add(kNclDedxMomentumPosAfter[i].data(), "Ncl vs dE/dx vs Momentum Positive after", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); - registryDeDx.add(kNclDedxMomentumNegAfter[i].data(), "Ncl vs dE/dx vs Momentum Negative after", HistType::kTH3F, - {{100, 0, 160, "N_{cl}"}, {dedxAxis}, {pAxis}}); + // Ncl vs de/dx ITS + if (nITSClCut) { + for (int i = 0; i < kEtaIntervals; ++i) { + registryDeDx.add(kNclITSDedxMomentumPosBefore[i].data(), "Ncl ITS vs dE/dx vs Momentum Positive before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclITSDedxMomentumNegBefore[i].data(), "Ncl ITS vs dE/dx vs Momentum Negative before", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + + registryDeDx.add(kNclITSDedxMomentumPosAfter[i].data(), "Ncl ITS vs dE/dx vs Momentum Positive after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclITSDedxMomentumNegAfter[i].data(), "Ncl ITS vs dE/dx vs Momentum Negative after", HistType::kTH3F, + {{100, 0, 160, "N_{cl}^{ITS}"}, {dedxAxis}, {pAxis}}); + } } // beta plot @@ -255,6 +354,48 @@ struct DedxPidAnalysis { // Event Counter registryDeDx.add("histRecVtxZData", "collision z position", HistType::kTH1F, {{100, -20.0, +20.0, "z_{vtx} (cm)"}}); + // Event Counter + registryDeDx.add("evsel", "events selected", HistType::kTH1F, {{5, 0.5, 5.5, ""}}); + auto hstat = registryDeDx.get(HIST("evsel")); + auto* x = hstat->GetXaxis(); + x->SetBinLabel(1, "AllEv"); + x->SetBinLabel(2, "SelEigth"); + x->SetBinLabel(3, "ZVtxCut"); + x->SetBinLabel(4, "NoSameBunchPileup"); + x->SetBinLabel(5, "GoodZvtxFT0vsPV"); + + // Track Counter + registryDeDx.add("trackselAll", "track selected all particles", HistType::kTH1F, {{5, 0.5, 5.5, ""}}); + auto htrackAll = registryDeDx.get(HIST("trackselAll")); + auto* xAll = htrackAll->GetXaxis(); + xAll->SetBinLabel(1, "AllPri"); + xAll->SetBinLabel(2, "SelectionPrim"); + xAll->SetBinLabel(3, "PhiVarCutPri"); + xAll->SetBinLabel(4, "NTPCClCutPri"); + xAll->SetBinLabel(5, "NITSClCutPri"); + + registryDeDx.add("trackselSec", "track selected sec particles", HistType::kTH1F, {{18, 0.5, 18.5, ""}}); + auto htrackSec = registryDeDx.get(HIST("trackselSec")); + auto* xSec = htrackSec->GetXaxis(); + xSec->SetBinLabel(1, "AllSec"); + xSec->SetBinLabel(2, "V0CosPA"); + xSec->SetBinLabel(3, "V0DecayRadius"); + xSec->SetBinLabel(4, "V0Daughters"); + xSec->SetBinLabel(5, "TPCRefit"); + xSec->SetBinLabel(6, "PhiVarCutSec"); + xSec->SetBinLabel(7, "NTPCClCutSec"); + xSec->SetBinLabel(8, "NITSClCutSec"); + xSec->SetBinLabel(9, "AllK0s"); + xSec->SetBinLabel(10, "V0RapidityK0s"); + xSec->SetBinLabel(11, "V0ProperLifetimeK0s"); + xSec->SetBinLabel(12, "AllLambda"); + xSec->SetBinLabel(13, "V0RapidityLambda"); + xSec->SetBinLabel(14, "V0ProperLifetimeLambda"); + xSec->SetBinLabel(15, "AllAntiLambda"); + xSec->SetBinLabel(16, "V0RapidityAntiLambda"); + xSec->SetBinLabel(17, "V0ProperLifetimeAntiLambda"); + xSec->SetBinLabel(18, "AllGamma"); + mySelectionPrim = myTrackSelection(); } @@ -265,8 +406,6 @@ struct DedxPidAnalysis { // Single-Track Selections if (!track.hasTPC()) return false; - if (track.tpcNClsFound() < minTPCnClsFound) - return false; if (track.tpcNClsCrossedRows() < minNCrossedRowsTPC) return false; if (track.tpcChi2NCl() > maxChi2TPC) @@ -283,8 +422,15 @@ struct DedxPidAnalysis { { if (v0.v0cosPA() < v0cospaMin) return false; + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0CosPA); + if (v0.v0radius() < minimumV0Radius || v0.v0radius() > maximumV0Radius) return false; + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0DecayRadius); + + if (v0.dcaV0daughters() > dcaV0DaughtersMax) + return false; + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0Daughters); return true; } @@ -299,18 +445,31 @@ struct DedxPidAnalysis { return false; if (!passedSingleTrackSelection(ntrack, collision)) return false; + double sigmap = 0.0; + double sigman = 0.0; + + if (V0SelectionMode == 1) { + sigmap = ptrack.tpcNSigmaPi(); + sigman = ntrack.tpcNSigmaPi(); + } else if (V0SelectionMode == 2) { + sigmap = ptrack.tofNSigmaPi(); + sigman = ntrack.tofNSigmaPi(); + } else if (V0SelectionMode == 3) { + sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaPi(), 2) + std::pow(ptrack.tofNSigmaPi(), 2)); + sigman = std::sqrt(std::pow(ntrack.tpcNSigmaPi(), 2) + std::pow(ntrack.tofNSigmaPi(), 2)); + } if (ptrack.tpcInnerParam() > tpcCut) { if (!ptrack.hasTOF()) return false; - if (std::abs(ptrack.tofNSigmaPi()) > nsigmaTOFmax) + if (std::abs(sigmap) > nsigmaTOFmax) return false; } if (ntrack.tpcInnerParam() > tpcCut) { if (!ntrack.hasTOF()) return false; - if (std::abs(ntrack.tofNSigmaPi()) > nsigmaTOFmax) + if (std::abs(sigman) > nsigmaTOFmax) return false; } @@ -332,17 +491,31 @@ struct DedxPidAnalysis { if (!passedSingleTrackSelection(ntrack, collision)) return false; + double sigmap = 0.0; + double sigman = 0.0; + + if (V0SelectionMode == 1) { + sigmap = ptrack.tpcNSigmaPr(); + sigman = ntrack.tpcNSigmaPi(); + } else if (V0SelectionMode == 2) { + sigmap = ptrack.tofNSigmaPr(); + sigman = ntrack.tofNSigmaPi(); + } else if (V0SelectionMode == 3) { + sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaPr(), 2) + std::pow(ptrack.tofNSigmaPr(), 2)); + sigman = std::sqrt(std::pow(ntrack.tpcNSigmaPi(), 2) + std::pow(ntrack.tofNSigmaPi(), 2)); + } + if (ptrack.tpcInnerParam() > tpcCut) { if (!ptrack.hasTOF()) return false; - if (std::abs(ptrack.tofNSigmaPr()) > nsigmaTOFmax) + if (std::abs(sigmap) > nsigmaTOFmax) return false; } if (ntrack.tpcInnerParam() > tpcCut) { if (!ntrack.hasTOF()) return false; - if (std::abs(ntrack.tofNSigmaPi()) > nsigmaTOFmax) + if (std::abs(sigman) > nsigmaTOFmax) return false; } @@ -364,18 +537,30 @@ struct DedxPidAnalysis { return false; if (!passedSingleTrackSelection(ntrack, collision)) return false; - + double sigmap = 0.0; + double sigman = 0.0; + + if (V0SelectionMode == 1) { + sigmap = ptrack.tpcNSigmaPi(); + sigman = ntrack.tpcNSigmaPr(); + } else if (V0SelectionMode == 2) { + sigmap = ptrack.tofNSigmaPi(); + sigman = ntrack.tofNSigmaPr(); + } else if (V0SelectionMode == 3) { + sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaPi(), 2) + std::pow(ptrack.tofNSigmaPi(), 2)); + sigman = std::sqrt(std::pow(ntrack.tpcNSigmaPr(), 2) + std::pow(ntrack.tofNSigmaPr(), 2)); + } if (ptrack.tpcInnerParam() > tpcCut) { if (!ptrack.hasTOF()) return false; - if (std::abs(ptrack.tofNSigmaPi()) > nsigmaTOFmax) + if (std::abs(sigmap) > nsigmaTOFmax) return false; } if (ntrack.tpcInnerParam() > tpcCut) { if (!ntrack.hasTOF()) return false; - if (std::abs(ntrack.tofNSigmaPr()) > nsigmaTOFmax) + if (std::abs(sigman) > nsigmaTOFmax) return false; } @@ -397,17 +582,31 @@ struct DedxPidAnalysis { if (!passedSingleTrackSelection(ntrack, collision)) return false; + double sigmap = 0.0; + double sigman = 0.0; + + if (V0SelectionMode == 1) { + sigmap = ptrack.tpcNSigmaEl(); + sigman = ntrack.tpcNSigmaEl(); + } else if (V0SelectionMode == 2) { + sigmap = ptrack.tofNSigmaEl(); + sigman = ntrack.tofNSigmaEl(); + } else if (V0SelectionMode == 3) { + sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaEl(), 2) + std::pow(ptrack.tofNSigmaEl(), 2)); + sigman = std::sqrt(std::pow(ntrack.tpcNSigmaEl(), 2) + std::pow(ntrack.tofNSigmaEl(), 2)); + } + if (ptrack.tpcInnerParam() > tpcCut) { if (!ptrack.hasTOF()) return false; - if (std::abs(ptrack.tofNSigmaEl()) > nsigmaTOFmax) + if (std::abs(sigmap) > nsigmaTOFmax) return false; } if (ntrack.tpcInnerParam() > tpcCut) { if (!ntrack.hasTOF()) return false; - if (std::abs(ntrack.tofNSigmaEl()) > nsigmaTOFmax) + if (std::abs(sigman) > nsigmaTOFmax) return false; } @@ -417,17 +616,30 @@ struct DedxPidAnalysis { return true; } - + // Magnetic field + int getMagneticField(uint64_t timestamp) + { + static o2::parameters::GRPMagField* grpo = nullptr; + if (grpo == nullptr) { + grpo = ccdb->getForTimeStamp("GLO/Config/GRPMagField", timestamp); + if (grpo == nullptr) { + LOGF(fatal, "GRP object not found for timestamp %llu", timestamp); + return 0; + } + LOGF(info, "Retrieved GRP for timestamp %llu with magnetic field of %d kG", timestamp, grpo->getNominalL3Field()); + } + return grpo->getNominalL3Field(); + } // Phi cut template - bool passedPhiCut(const T& trk, float magField, const TF1& fphiCutLow, const TF1& fphiCutHigh) + bool passedPhiCutPri(const T& trk, float magField, const TF1& fphiCutLow, const TF1& fphiCutHigh) { + float p = trk.pt(); float pt = trk.pt(); float phi = trk.phi(); int charge = trk.sign(); float eta = trk.eta(); - auto nTPCCl = trk.tpcNClsFindable() - trk.tpcNClsFindableMinusFound(); - float sigP = trk.sign() * trk.tpcInnerParam(); + auto nTPCCl = trk.tpcNClsFound(); if (pt < pTcut) return true; @@ -441,115 +653,243 @@ struct DedxPidAnalysis { phi += o2::constants::math::PI / 18.0f; phi = std::fmod(phi, o2::constants::math::PI / 9.0f); - registryDeDx.fill(HIST("hpt_vs_phi_Ncl_Before"), pt, phi, nTPCCl); + registryDeDx.fill(HIST("hpt_vs_phi_Ncl_TPC_Before"), pt, phi, nTPCCl); + registryDeDx.fill(HIST("hp_vs_phi_Ncl_TPC_Before"), p, phi, nTPCCl); + registryDeDx.fill(HIST("heta_vs_Ncl_TPC_Before"), eta, nTPCCl); // cut phi if (phi < fphiCutHigh.Eval(pt) && phi > fphiCutLow.Eval(pt)) return false; // reject track + registryDeDx.fill(HIST("hpt_vs_phi_Ncl_TPC_After"), pt, phi, nTPCCl); + registryDeDx.fill(HIST("hp_vs_phi_Ncl_TPC_After"), p, phi, nTPCCl); + registryDeDx.fill(HIST("heta_vs_Ncl_TPC_After"), eta, nTPCCl); + + return true; + } + + // NclCutTPC + template + bool passedNTPCClCutPri(const T& trk) + { + float eta = trk.eta(); + float sigP = trk.sign() * trk.tpcInnerParam(); + auto nTPCCl = trk.tpcNClsFound(); + if (eta > EtaCut[0] && eta < EtaCut[1]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[0]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[0]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[1] && eta < EtaCut[2]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[1]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[1]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[2] && eta < EtaCut[3]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[2]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[2]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[3] && eta < EtaCut[4]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[3]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[3]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[4] && eta < EtaCut[5]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[4]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[4]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[5] && eta < EtaCut[6]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[5]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[5]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[6] && eta < EtaCut[7]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[6]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[6]), nTPCCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegBefore[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosBefore[7]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[7]), nTPCCl, trk.tpcSignal(), sigP); } } - // cut Ncl - if (nTPCCl < nclCut) + if (nTPCCl < minTPCnClsFound) return false; - registryDeDx.fill(HIST("hpt_vs_phi_Ncl_After"), pt, phi, nTPCCl); + if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[0]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[1]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[2]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[3]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[4]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[5]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[6]), nTPCCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclTPCDedxMomentumPosAfter[7]), nTPCCl, trk.tpcSignal(), sigP); + } + } + + return true; + } + + // NclCutITS + template + bool passedNITSClCutPri(const T& trk) + { + float eta = trk.eta(); + float sigP = trk.sign() * trk.tpcInnerParam(); + auto nITSCl = trk.itsNCls(); if (eta > EtaCut[0] && eta < EtaCut[1]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[0]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[0]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[0]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[1] && eta < EtaCut[2]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[1]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[1]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[1]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[2] && eta < EtaCut[3]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[2]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[2]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[2]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[3] && eta < EtaCut[4]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[3]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[3]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[3]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[4] && eta < EtaCut[5]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[4]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[4]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[4]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[5] && eta < EtaCut[6]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[5]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[5]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[5]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[6] && eta < EtaCut[7]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[6]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[6]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[6]), nITSCl, trk.tpcSignal(), sigP); } } else if (eta > EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclDedxMomentumNegAfter[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[7]), nITSCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclDedxMomentumPosAfter[7]), nTPCCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[7]), nITSCl, trk.tpcSignal(), sigP); + } + } + + if (nITSCl < minITSnCls) + return false; + + if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[0]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[0]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[1]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[1]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[2]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[2]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[3]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[3]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[4]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[4]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[5]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[5]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[6]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[6]), nITSCl, trk.tpcSignal(), sigP); + } + } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + if (sigP < 0) { + registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[7]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + } else { + registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[7]), nITSCl, trk.tpcSignal(), sigP); } } @@ -563,7 +903,6 @@ struct DedxPidAnalysis { float pt = trk.pt(); float phi = trk.phi(); int charge = trk.sign(); - auto nTPCCl = trk.tpcNClsFindable() - trk.tpcNClsFindableMinusFound(); if (pt < pTcut) return true; @@ -581,42 +920,94 @@ struct DedxPidAnalysis { if (phi < fphiCutHigh.Eval(pt) && phi > fphiCutLow.Eval(pt)) return false; // reject track - // cut Ncl - if (nTPCCl < nclCut) + return true; + } + + // NclCutTPC + template + bool passedNTPCClCutSecondaries(const T& trk) + { + auto nTPCCl = trk.tpcNClsFound(); + + if (nTPCCl < minTPCnClsFound) + return false; + + return true; + } + + // NclCutITS primary + template + bool passedNITSClCutSecondaries(const T& trk) + { + auto nITSCl = trk.itsNCls(); + + if (nITSCl < minITSnCls) return false; return true; } // Process Data - void process(SelectedCollisions::iterator const& collision, + void process(SelectedCollisions::iterator const& collision, BCsRun3 const& /**/, aod::V0Datas const& fullV0s, PIDTracks const& tracks) { + registryDeDx.fill(HIST("evsel"), EvCutLabel::AllEv); // Event Selection if (!collision.sel8()) return; + registryDeDx.fill(HIST("evsel"), EvCutLabel::SelEigth); + if (std::abs(collision.posZ()) > maxZDistanceToIP) return; + registryDeDx.fill(HIST("evsel"), EvCutLabel::ZVtxCut); + + if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) + return; + + registryDeDx.fill(HIST("evsel"), EvCutLabel::NoSameBunchPileup); + + if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) + return; + + registryDeDx.fill(HIST("evsel"), EvCutLabel::GoodZvtxFT0vsPV); + // Event Counter registryDeDx.fill(HIST("histRecVtxZData"), collision.posZ()); - // Kaons - for (const auto& trk : tracks) { + // For magnetic field + const auto& foundBC = collision.foundBC_as(); + const uint64_t timeStamp{foundBC.timestamp()}; + const int magField{getMagneticField(timeStamp)}; + for (const auto& trk : tracks) { + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::AllPri); // track Selection - if (!passedSingleTrackSelection(trk, collision)) - continue; - if (!mySelectionPrim.IsSelected(trk)) continue; + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::SelectionPrim); + // phi and Ncl cut - if (additionalCuts) { - if (!passedPhiCut(trk, magField, *fphiCutLow, *fphiCutHigh)) + if (phiVarCut) { + if (!passedPhiCutPri(trk, magField, *fphiCutLow, *fphiCutHigh)) continue; } + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::PhiVarCutPri); + // NCl cut ITS + if (nTPCClCut) { + if (!passedNTPCClCutPri(trk)) + continue; + } + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NTPCClCutPri); + + // NCl cut ITS + if (nITSClCut) { + if (!passedNITSClCutPri(trk)) + continue; + } + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NITSClCutPri); float signedP = trk.sign() * trk.tpcInnerParam(); @@ -710,14 +1101,11 @@ struct DedxPidAnalysis { for (const auto& v0 : fullV0s) { // Standard V0 Selections + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllSec); if (!passedV0Selection(v0, collision)) { continue; } - if (v0.dcaV0daughters() > dcaV0DaughtersMax) { - continue; - } - // Positive and Negative Tracks const auto& posTrack = v0.posTrack_as(); const auto& negTrack = v0.negTrack_as(); @@ -726,14 +1114,37 @@ struct DedxPidAnalysis { continue; if (!negTrack.passedTPCRefit()) continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::TPCRefit); // phi and Ncl cut - if (additionalCuts) { + if (phiVarCut) { if (!passedPhiCutSecondaries(posTrack, magField, *fphiCutLow, *fphiCutHigh)) continue; if (!passedPhiCutSecondaries(negTrack, magField, *fphiCutLow, *fphiCutHigh)) continue; } + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::PhiVarCutSec); + + if (nTPCClCut) { + if (!passedNTPCClCutSecondaries(posTrack)) + continue; + + if (!passedNTPCClCutSecondaries(negTrack)) + continue; + } + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NTPCClCutSec); + + if (nITSClCut) { + if (!passedNITSClCutSecondaries(posTrack)) + continue; + + if (!passedNITSClCutSecondaries(negTrack)) + continue; + } + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NITSClCutSec); float signedPpos = posTrack.sign() * posTrack.tpcInnerParam(); float signedPneg = negTrack.sign() * negTrack.tpcInnerParam(); @@ -750,6 +1161,19 @@ struct DedxPidAnalysis { // K0s Selection if (passedK0Selection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllK0s); + + if (std::abs(v0.rapidity(MassK0Short)) > v0rapidityCut) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityK0s); + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassK0Short; + + if (properLifetime > v0ProperLifetimeCutK0s) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeK0s); + float ePosPi = posTrack.energy(MassPionCharged); float eNegPi = negTrack.energy(MassPionCharged); @@ -771,6 +1195,18 @@ struct DedxPidAnalysis { // Lambda Selection if (passedLambdaSelection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllLambda); + + if (std::abs(v0.rapidity(MassLambda)) > v0rapidityCut) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityLambda); + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassLambda; + + if (properLifetime > v0ProperLifetimeCutLambda) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeLambda); float ePosPr = posTrack.energy(MassProton); float eNegPi = negTrack.energy(MassPionCharged); @@ -793,6 +1229,18 @@ struct DedxPidAnalysis { // AntiLambda Selection if (passedAntiLambdaSelection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllAntiLambda); + + if (std::abs(v0.rapidity(MassLambda)) > v0rapidityCut) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityAntiLambda); + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassLambda; + + if (properLifetime > v0ProperLifetimeCutLambda) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeAntiLambda); float ePosPi = posTrack.energy(MassPionCharged); float eNegPr = negTrack.energy(MassProton); @@ -815,6 +1263,7 @@ struct DedxPidAnalysis { // Gamma Selection if (passedGammaSelection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllGamma); float ePosEl = posTrack.energy(MassElectron); float eNegEl = negTrack.energy(MassElectron); From 1e194135d7f208df876efbf3c0f2876c914a77a6 Mon Sep 17 00:00:00 2001 From: Paola Vargas Torres Date: Thu, 11 Sep 2025 16:04:30 -0600 Subject: [PATCH 7/7] New histograms, event and track seleccions were implemented --- PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx | 35 ++++++++++++++------------ 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx index 851d1634b68..97b518ce194 100644 --- a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx +++ b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx @@ -69,6 +69,9 @@ struct DedxPidAnalysis { float invMassCut = 0.01; float invMassCutGamma = 0.0015; float pTcut = 2.0; + int v0TPC = 1; + int v0TOF = 2; + int v0TPCTOF = 3; // Event cut labels enum EvCutLabel { @@ -153,7 +156,7 @@ struct DedxPidAnalysis { Configurable phiVarCut{"phiVarCut", true, "phi var cut"}; Configurable nTPCClCut{"nTPCClCut", true, "number of clusters in TPC cut"}; Configurable nITSClCut{"nITSClCut", true, "number of clusters in ITS cut"}; - Configurable V0SelectionMode{"V0SelectionMode", 1, "V0 Selection base on TPC: 1, TOF:2 ,Both:3"}; + Configurable v0SelectionMode{"v0SelectionMode", 1, "V0 Selection base on TPC: 1, TOF:2 ,Both:3"}; // Histograms names static constexpr std::string_view kDedxvsMomentumPos[kParticlesType] = {"dEdx_vs_Momentum_all_Pos", "dEdx_vs_Momentum_Pi_v0_Pos", "dEdx_vs_Momentum_Pr_v0_Pos", "dEdx_vs_Momentum_El_v0_Pos"}; static constexpr std::string_view kDedxvsMomentumNeg[kParticlesType] = {"dEdx_vs_Momentum_all_Neg", "dEdx_vs_Momentum_Pi_v0_Neg", "dEdx_vs_Momentum_Pr_v0_Neg", "dEdx_vs_Momentum_El_v0_Neg"}; @@ -200,11 +203,11 @@ struct DedxPidAnalysis { void init(InitContext const&) { - if (V0SelectionMode == 1) { + if (V0SelectionMode == v0TPC) { LOGF(info, "V0 seleccion using TPC only"); - } else if (V0SelectionMode == 2) { + } else if (V0SelectionMode == v0TOF) { LOGF(info, "V0 seleccion using TOF only"); - } else if (V0SelectionMode == 3) { + } else if (V0SelectionMode == v0TPCTOF) { LOGF(info, "V0 seleccion using TOF + TPC"); } @@ -448,13 +451,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (V0SelectionMode == 1) { + if (V0SelectionMode == v0TPC) { sigmap = ptrack.tpcNSigmaPi(); sigman = ntrack.tpcNSigmaPi(); - } else if (V0SelectionMode == 2) { + } else if (V0SelectionMode == v0TOF) { sigmap = ptrack.tofNSigmaPi(); sigman = ntrack.tofNSigmaPi(); - } else if (V0SelectionMode == 3) { + } else if (V0SelectionMode == v0TPCTOF) { sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaPi(), 2) + std::pow(ptrack.tofNSigmaPi(), 2)); sigman = std::sqrt(std::pow(ntrack.tpcNSigmaPi(), 2) + std::pow(ntrack.tofNSigmaPi(), 2)); } @@ -494,13 +497,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (V0SelectionMode == 1) { + if (V0SelectionMode == v0TPC) { sigmap = ptrack.tpcNSigmaPr(); sigman = ntrack.tpcNSigmaPi(); - } else if (V0SelectionMode == 2) { + } else if (V0SelectionMode == v0TOF) { sigmap = ptrack.tofNSigmaPr(); sigman = ntrack.tofNSigmaPi(); - } else if (V0SelectionMode == 3) { + } else if (V0SelectionMode == v0TPCTOF) { sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaPr(), 2) + std::pow(ptrack.tofNSigmaPr(), 2)); sigman = std::sqrt(std::pow(ntrack.tpcNSigmaPi(), 2) + std::pow(ntrack.tofNSigmaPi(), 2)); } @@ -540,13 +543,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (V0SelectionMode == 1) { + if (V0SelectionMode == v0TPC) { sigmap = ptrack.tpcNSigmaPi(); sigman = ntrack.tpcNSigmaPr(); - } else if (V0SelectionMode == 2) { + } else if (V0SelectionMode == v0TOF) { sigmap = ptrack.tofNSigmaPi(); sigman = ntrack.tofNSigmaPr(); - } else if (V0SelectionMode == 3) { + } else if (V0SelectionMode == v0TPCTOF) { sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaPi(), 2) + std::pow(ptrack.tofNSigmaPi(), 2)); sigman = std::sqrt(std::pow(ntrack.tpcNSigmaPr(), 2) + std::pow(ntrack.tofNSigmaPr(), 2)); } @@ -585,13 +588,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (V0SelectionMode == 1) { + if (V0SelectionMode == v0TPC) { sigmap = ptrack.tpcNSigmaEl(); sigman = ntrack.tpcNSigmaEl(); - } else if (V0SelectionMode == 2) { + } else if (V0SelectionMode == v0TOF) { sigmap = ptrack.tofNSigmaEl(); sigman = ntrack.tofNSigmaEl(); - } else if (V0SelectionMode == 3) { + } else if (V0SelectionMode == v0TPCTOF) { sigmap = std::sqrt(std::pow(ptrack.tpcNSigmaEl(), 2) + std::pow(ptrack.tofNSigmaEl(), 2)); sigman = std::sqrt(std::pow(ntrack.tpcNSigmaEl(), 2) + std::pow(ntrack.tofNSigmaEl(), 2)); }