diff --git a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx index 86d9030e6ff..de4be8cf34b 100644 --- a/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx +++ b/PWGLF/Tasks/Nuspex/dedxPidAnalysis.cxx @@ -20,6 +20,7 @@ #include "Common/Core/TrackSelection.h" #include "Common/Core/TrackSelectionDefaults.h" #include "Common/Core/trackUtilities.h" +#include "Common/DataModel/Centrality.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/PIDResponse.h" @@ -31,6 +32,7 @@ #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" #include "Framework/Logger.h" #include "Framework/runDataProcessing.h" #include "ReconstructionDataFormats/Track.h" @@ -46,9 +48,13 @@ using PIDTracks = soa::Join< aod::Tracks, aod::TracksExtra, aod::TrackSelectionExtension, aod::TracksDCA, aod::TrackSelection, aod::pidTOFFullPi, aod::pidTOFFullPr, aod::pidTOFFullEl, aod::pidTOFbeta, aod::pidTPCPi, aod::pidTPCPr, aod::pidTPCEl>; -using SelectedCollisions = soa::Join; +using SelectedCollisions = soa::Join; using BCsRun3 = soa::Join; +static constexpr int kNCentHists{10}; +std::array, kNCentHists> hDedxVsMomentumVsCentPos{}; +std::array, kNCentHists> hDedxVsMomentumVsCentNeg{}; + struct DedxPidAnalysis { // dE/dx for all charged particles @@ -61,17 +67,27 @@ struct DedxPidAnalysis { // Constant values static constexpr int kEtaIntervals = 8; static constexpr int kParticlesType = 4; + static constexpr int kCentralityClasses = 10; 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 pTcut = 2.0; - int v0TPC = 1; - int v0TOF = 2; - int v0TPCTOF = 3; + + bool fillHist = false; + + enum V0SelectionMode { + V0TPC = 1, + V0TOF = 2, + V0TPCTOF = 3 + + }; + + enum MomentumMode { + TpcInnerParam = 1, + TotalMomentum = 2 + }; // Event cut labels enum EvCutLabel { @@ -88,37 +104,43 @@ struct DedxPidAnalysis { AllPri = 1, SelectionPrim, PhiVarCutPri, - NTPCClCutPri, - NITSClCutPri + NClTPCFoundCutPri, + NClTPCPIDCutPri }; // Track secondary lebel enum TrkSecCutLabel { AllSec = 1, + V0Type, V0CosPA, V0DecayRadius, V0Daughters, TPCRefit, PhiVarCutSec, - NTPCClCutSec, - NITSClCutSec, + NClTPCFoundCutSec, + NClTPCPIDCutSec, AllK0s, V0RapidityK0s, V0ProperLifetimeK0s, + MassCutK0s, AllLambda, V0RapidityLambda, V0ProperLifetimeLambda, + MassCutLambda, AllAntiLambda, V0RapidityAntiLambda, V0ProperLifetimeAntiLambda, - AllGamma + MassCutAntiLambda, + AllGamma, + V0RapidityGamma, + MassCutGamma }; // Configurable Parameters // Tracks cuts - Configurable minTPCnClsFound{"minTPCnClsFound", 135.0f, + Configurable minTPCnClsFound{"minTPCnClsFound", 70.0f, "min number of found TPC clusters"}; - Configurable minITSnCls{"minITSnCls", 0.0f, - "min number of ITS clusters"}; + Configurable minTPCnClsPID{"minTPCnClsPID", 70.0f, + "min number of PID TPC clusters"}; Configurable minNCrossedRowsTPC{"minNCrossedRowsTPC", 70.0f, "min number of found TPC crossed rows"}; Configurable maxChi2TPC{"maxChi2TPC", 4.0f, "max chi2 per cluster TPC"}; @@ -142,35 +164,37 @@ struct DedxPidAnalysis { 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"}; - 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 invMassCutK0s{"invMassCutK0s", 0.2f, "invariant Mass Cut for K0s"}; + Configurable invMassCutLambda{"invMassCutLambda", 0.1f, "invariant Mass Cut for Lambda"}; + Configurable invMassCutGamma{"invMassCutGamma", 0.1f, "invariant Mass Cut for Gamma"}; Configurable calibrationMode{"calibrationMode", false, "calibration mode"}; 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 nClTPCFoundCut{"nClTPCFoundCut", false, "number of found clusters in TPC cut"}; + Configurable nClTPCPIDCut{"nClTPCPIDCut", true, "number of PID clusters in TPC cut"}; + Configurable v0SelectionMode{"v0SelectionMode", 3, "V0 Selection base on TPC: 1, TOF:2 ,Both:3"}; + Configurable momentumMode{"momentumMode", 1, "1: TPC inner param, 2: Total momentum p"}; + Configurable v0TypeSelection{"v0TypeSelection", 1, "select on a certain V0 type (leave negative if no selection desired)"}; + Configurable lowParam1{"lowParam1", 0.119297, "First parameter for low phi cut"}; + Configurable lowParam2{"lowParam2", 0.000379693, "Second parameter for low phi cut"}; + Configurable highParam1{"highParam1", 0.16685, "First parameter for high phi cut"}; + Configurable highParam2{"highParam2", 0.00981942, "Second parameter for high phi 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 kDedxvsMomentumvsCentPos[kCentralityClasses] = {"dEdx_vs_Momentum_Cent0_1_Pos", "dEdx_vs_Momentum_Cent1_5_Pos", "dEdx_vs_Momentum_Cent5_10_Pos", "dEdx_vs_Momentum_Cent10_15_Pos", "dEdx_vs_Momentum_Cent15_20_Pos", "dEdx_vs_Momentum_Cent20_30_Pos", "dEdx_vs_Momentum_Cent30_40_Pos", "dEdx_vs_Momentum_Cent40_50_Pos", "dEdx_vs_Momentum_Cent50_70_Pos", "dEdx_vs_Momentum_Cent70_100_Pos"}; + static constexpr std::string_view kDedxvsMomentumvsCentNeg[kCentralityClasses] = {"dEdx_vs_Momentum_Cent0_1_Neg", "dEdx_vs_Momentum_Cent1_5_Neg", "dEdx_vs_Momentum_Cent5_10_Neg", "dEdx_vs_Momentum_Cent10_15_Neg", "dEdx_vs_Momentum_Cent15_20_Neg", "dEdx_vs_Momentum_Cent20_30_Neg", "dEdx_vs_Momentum_Cent30_40_Neg", "dEdx_vs_Momentum_Cent40_50_Neg", "dEdx_vs_Momentum_Cent50_70_Neg", "dEdx_vs_Momentum_Cent70_100_Neg"}; // 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 std::string_view kNclTPCDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_8_Before"}; + static constexpr std::string_view kNclTPCDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_8_Before"}; + static constexpr std::string_view kNclTPCDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_TFoundPC_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Neg_8_After"}; + static constexpr std::string_view kNclTPCDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_FoundTPC_vs_dEdx_vs_Momentum_Pos_8_After"}; + // Ncl PID TPC + static constexpr std::string_view kNclPIDTPCDedxMomentumNegBefore[kEtaIntervals] = {"Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_1_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_2_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_3_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_4_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_5_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_6_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_7_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_8_Before"}; + static constexpr std::string_view kNclPIDTPCDedxMomentumPosBefore[kEtaIntervals] = {"Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_1_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_2_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_3_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_4_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_5_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_6_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_7_Before", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_8_Before"}; + static constexpr std::string_view kNclPIDTPCDedxMomentumNegAfter[kEtaIntervals] = {"Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_1_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_2_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_3_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_4_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_5_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_6_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_7_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Neg_8_After"}; + static constexpr std::string_view kNclPIDTPCDedxMomentumPosAfter[kEtaIntervals] = {"Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_1_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_2_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_3_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_4_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_5_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_6_After", "Ncl_PIDTPC_vs_dEdx_vs_Momentum_Pos_7_After", "Ncl_PIDTPC_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}; + static constexpr double CentClasses[kCentralityClasses + 1] = {0.0, 0.1, 5.0, 10.0, 15.0, 20.0, 30.0, 40.0, 50.0, 70.0, 100.0}; 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}, ""}; @@ -203,20 +227,58 @@ struct DedxPidAnalysis { void init(InitContext const&) { - if (v0SelectionMode == v0TPC) { + if (v0SelectionMode == V0TPC) { LOGF(info, "V0 seleccion using TPC only"); - } else if (v0SelectionMode == v0TOF) { + } else if (v0SelectionMode == V0TOF) { LOGF(info, "V0 seleccion using TOF only"); - } else if (v0SelectionMode == v0TPCTOF) { + } else if (v0SelectionMode == V0TPCTOF) { LOGF(info, "V0 seleccion using TOF + TPC"); } + if (calibrationMode) { + LOGF(info, "Calibration mode activated"); + } else { + LOGF(info, "Running data applying calibration values"); + } + + if (phiVarCut) { + LOGF(info, "Applying phi prime cut"); + } else { + LOGF(info, "Phi prime cut disabled"); + } + + if (nClTPCFoundCut) { + LOGF(info, "Applying TPC found clusters cut"); + } else { + LOGF(info, "TPC found clusters cut disabled"); + } + + if (nClTPCPIDCut) { + LOGF(info, "Applying TPC clusters for PID cut"); + } else { + LOGF(info, "TPC clusters for PID cut disabled"); + } + if (momentumMode == TpcInnerParam) { + LOGF(info, "Using TPC inner parameter for momentum calculation"); + } else { + LOGF(info, "Using total momentum (p) for calculation"); + } + LOGF(info, "Centrality clases between %.1f - %.1f", CentClasses[0], CentClasses[10]); 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); + AxisSpec pAxisTrack = {binP, "#it{p} (GeV/c)"}; + fphiCutLow = new TF1("StandardPhiCutLow", + Form("%f/x/x+pi/18.0-%f", lowParam1.value, lowParam2.value), + 0, 50); + fphiCutHigh = new TF1("StandardPhiCutHigh", + Form("%f/x+pi/18.0+%f", highParam1.value, highParam2.value), + 0, 50); + LOGF(info, "=== Phi Cut Parameters ==="); + LOGF(info, "Low cut: %.6f/x² + pi/18 - %.6f", lowParam1.value, lowParam2.value); + LOGF(info, "High cut: %.6f/x + pi/18 + %.6f", highParam1.value, highParam2.value); + if (calibrationMode) { // MIP for pions registryDeDx.add( @@ -270,18 +332,23 @@ struct DedxPidAnalysis { // pt vs p registryDeDx.add( - "heta_vs_p_vs_pt_all_Neg", "eta_vs_p_vs_pT", HistType::kTH3F, - {{etaAxis}, {ptAxis}, {pAxis}}); + "heta_vs_pt_vs_p_all_Neg", "eta_vs_pT_vs_p", HistType::kTH3F, + {{etaAxis}, {ptAxis}, {pAxisTrack}}); registryDeDx.add( - "heta_vs_p_vs_pt_all_Pos", "eta_vs_p_vs_pT", HistType::kTH3F, - {{etaAxis}, {ptAxis}, {pAxis}}); + "heta_vs_pt_vs_p_all_Pos", "eta_vs_pT_vs_p", HistType::kTH3F, + {{etaAxis}, {ptAxis}, {pAxisTrack}}); // 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}}); + {{pAxisTrack}, {dedxAxis}, {etaAxis}}); registryDeDx.add(kDedxvsMomentumNeg[i].data(), "dE/dx", HistType::kTH3F, - {{pAxis}, {dedxAxis}, {etaAxis}}); + {{pAxisTrack}, {dedxAxis}, {etaAxis}}); + } + + for (int i = 0; i < kCentralityClasses; ++i) { + hDedxVsMomentumVsCentPos[i] = registryDeDx.add(kDedxvsMomentumvsCentPos[i].data(), "dE/dx", HistType::kTH3F, {{pAxisTrack}, {dedxAxis}, {etaAxis}}); + hDedxVsMomentumVsCentNeg[i] = registryDeDx.add(kDedxvsMomentumvsCentNeg[i].data(), "dE/dx", HistType::kTH3F, {{pAxisTrack}, {dedxAxis}, {etaAxis}}); } } @@ -290,60 +357,159 @@ struct DedxPidAnalysis { {{100, 0.0, 6.4, "#phi"}, {dedxAxis}}); // phi cut if (phiVarCut) { - // pt + // pt for found 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}"}}); + "hpt_vs_phi_NclFound_TPC_After", "phi cut vs pt", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, found}"}}); 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}"}}); + "hpt_vs_phi_NclFound_TPC_Before", "phi cut vs pt", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, found}"}}); // 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}"}}); + "hp_vs_phi_NclFound_TPC_After", "phi cut vs p", HistType::kTH3F, + {{pAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, found}"}}); 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 + "hp_vs_phi_NclFound_TPC_Before", "phi cut vs p", HistType::kTH3F, + {{pAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, found}"}}); + + // pt for PID registryDeDx.add( - "heta_vs_Ncl_TPC_Before", "eta and N_{cl}", HistType::kTH2F, - {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl}"}}); + "hpt_vs_phi_NclPID_TPC_After", "phi cut vs pt", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, PID}"}}); registryDeDx.add( - "heta_vs_Ncl_TPC_After", "eta and N_{cl} ", HistType::kTH2F, - {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl}"}}); + "hpt_vs_phi_NclPID_TPC_Before", "phi cut vs pt", HistType::kTH3F, + {{ptAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, PID}"}}); + // p + registryDeDx.add( + "hp_vs_phi_NclPID_TPC_After", "phi cut vs p", HistType::kTH3F, + {{pAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_phi_NclPID_TPC_Before", "phi cut vs p", HistType::kTH3F, + {{pAxis}, {100, 0.0, 0.4, "#varphi^{'}"}, {100, 0, 160, "N_{cl, PID}"}}); } // Ncl vs de/dx TPC - if (nTPCClCut) { + if (nClTPCFoundCut) { 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(kNclTPCDedxMomentumPosBefore[i].data(), "Ncl found TPC vs dE/dx vs Momentum Positive before", HistType::kTH3F, + {{100, 0, 160, "N_{cl, found}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclTPCDedxMomentumNegBefore[i].data(), "Ncl found TPC vs dE/dx vs Momentum Negative before", HistType::kTH3F, + {{100, 0, 160, "N_{cl, found}^{TPC}"}, {dedxAxis}, {pAxis}}); + + registryDeDx.add(kNclTPCDedxMomentumPosAfter[i].data(), "Ncl found TPC vs dE/dx vs Momentum Positive after", HistType::kTH3F, + {{100, 0, 160, "N_{cl, found}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclTPCDedxMomentumNegAfter[i].data(), "Ncl found TPC vs dE/dx vs Momentum Negative after", HistType::kTH3F, + {{100, 0, 160, "N_{cl, found}^{TPC}"}, {dedxAxis}, {pAxis}}); } } // Ncl vs de/dx ITS - if (nITSClCut) { + if (nClTPCPIDCut) { 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}}); + registryDeDx.add(kNclPIDTPCDedxMomentumPosBefore[i].data(), "Ncl PID TPC vs dE/dx vs Momentum Positive before", HistType::kTH3F, + {{100, 0, 160, "N_{cl, PID}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclPIDTPCDedxMomentumNegBefore[i].data(), "Ncl PID TPC vs dE/dx vs Momentum Negative before", HistType::kTH3F, + {{100, 0, 160, "N_{cl, PID}^{TPC}"}, {dedxAxis}, {pAxis}}); + + registryDeDx.add(kNclPIDTPCDedxMomentumPosAfter[i].data(), "Ncl PID TPC vs dE/dx vs Momentum Positive after", HistType::kTH3F, + {{100, 0, 160, "N_{cl, PID}^{TPC}"}, {dedxAxis}, {pAxis}}); + registryDeDx.add(kNclPIDTPCDedxMomentumNegAfter[i].data(), "Ncl PID TPC vs dE/dx vs Momentum Negative after", HistType::kTH3F, + {{100, 0, 160, "N_{cl, PID}^{TPC}"}, {dedxAxis}, {pAxis}}); } } + // eta + registryDeDx.add( + "heta_vs_NclFound_TPC_Before_Primary", "eta and N_{cl}", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, found}"}}); + + registryDeDx.add( + "heta_vs_NclFound_TPC_After_Primary", "eta and N_{cl} ", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, found}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_Before_Primary", "eta and N_{cl, PID}", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_After_Primary", "eta and N_{cl, PID} ", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + // momentum for primaries + registryDeDx.add( + "hp_vs_NclPID_TPC_Before_Primary", "p and N_{cl, PID}", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_After_Primary", "p and N_{cl, PID} ", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + // eta for secondaries + registryDeDx.add( + "heta_vs_NclPID_TPC_Before_PionsK0s", "eta and N_{cl, PID}", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_After_PionsK0s", "eta and N_{cl, PID} ", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_Before_PionsLambda", "eta and N_{cl, PID}", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_After_PionsLambda", "eta and N_{cl, PID} ", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_Before_ProtonsLambda", "eta and N_{cl, PID}", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_After_ProtonsLambda", "eta and N_{cl, PID} ", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_Before_ElectronsGamma", "eta and N_{cl, PID}", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "heta_vs_NclPID_TPC_After_ElectronsGamma", "eta and N_{cl, PID} ", HistType::kTH2F, + {{100, -0.8, 0.8, "#eta"}, {100, 0, 160, "N_{cl, PID}"}}); + + // momentum for secondaries + registryDeDx.add( + "hp_vs_NclPID_TPC_Before_PionsK0s", "p and N_{cl, PID}", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_After_PionsK0s", "p and N_{cl, PID} ", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_Before_PionsLambda", "p and N_{cl, PID}", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_After_PionsLambda", "p and N_{cl, PID} ", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_Before_ProtonsLambda", "p and N_{cl, PID}", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_After_ProtonsLambda", "p and N_{cl, PID} ", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_Before_ElectronsGamma", "p and N_{cl, PID}", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); + + registryDeDx.add( + "hp_vs_NclPID_TPC_After_ElectronsGamma", "p and N_{cl, PID} ", HistType::kTH2F, + {{pAxisTrack}, {100, 0, 160, "N_{cl, PID}"}}); // beta plot registryDeDx.add( @@ -368,36 +534,42 @@ struct DedxPidAnalysis { x->SetBinLabel(GoodZvtxFT0vsPV, "GoodZvtxFT0vsPV"); // Track Counter - registryDeDx.add("trackselAll", "track selected all particles", HistType::kTH1F, {{5, 0.5, 5.5, ""}}); + registryDeDx.add("trackselAll", "track selected all particles", HistType::kTH1F, {{5, 0.5, 6.5, ""}}); auto htrackAll = registryDeDx.get(HIST("trackselAll")); auto* xAll = htrackAll->GetXaxis(); xAll->SetBinLabel(AllPri, "AllPri"); xAll->SetBinLabel(SelectionPrim, "SelectionPrim"); xAll->SetBinLabel(PhiVarCutPri, "PhiVarCutPri"); - xAll->SetBinLabel(NTPCClCutPri, "NTPCClCutPri"); - xAll->SetBinLabel(NITSClCutPri, "NITSClCutPri"); + xAll->SetBinLabel(NClTPCFoundCutPri, "NClTPCFoundCutPri"); + xAll->SetBinLabel(NClTPCPIDCutPri, "NClTPCPIDCutPri"); - registryDeDx.add("trackselSec", "track selected sec particles", HistType::kTH1F, {{18, 0.5, 18.5, ""}}); + registryDeDx.add("trackselSec", "track selected sec particles", HistType::kTH1F, {{24, 0.5, 24.5, ""}}); auto htrackSec = registryDeDx.get(HIST("trackselSec")); auto* xSec = htrackSec->GetXaxis(); xSec->SetBinLabel(AllSec, "AllSec"); + xSec->SetBinLabel(V0Type, "V0Type"); xSec->SetBinLabel(V0CosPA, "V0CosPA"); xSec->SetBinLabel(V0DecayRadius, "V0DecayRadius"); xSec->SetBinLabel(V0Daughters, "V0Daughters"); xSec->SetBinLabel(TPCRefit, "TPCRefit"); xSec->SetBinLabel(PhiVarCutSec, "PhiVarCutSec"); - xSec->SetBinLabel(NTPCClCutSec, "NTPCClCutSec"); - xSec->SetBinLabel(NITSClCutSec, "NITSClCutSec"); + xSec->SetBinLabel(NClTPCFoundCutSec, "NClTPCFoundCutSec"); + xSec->SetBinLabel(NClTPCPIDCutSec, "NClTPCPIDCutSec"); xSec->SetBinLabel(AllK0s, "AllK0s"); xSec->SetBinLabel(V0RapidityK0s, "V0RapidityK0s"); xSec->SetBinLabel(V0ProperLifetimeK0s, "V0ProperLifetimeK0s"); + xSec->SetBinLabel(MassCutK0s, "MassCutK0s"); xSec->SetBinLabel(AllLambda, "AllLambda"); xSec->SetBinLabel(V0RapidityLambda, "V0RapidityLambda"); xSec->SetBinLabel(V0ProperLifetimeLambda, "V0ProperLifetimeLambda"); + xSec->SetBinLabel(MassCutLambda, "MassCutLambda"); xSec->SetBinLabel(AllAntiLambda, "AllAntiLambda"); xSec->SetBinLabel(V0RapidityAntiLambda, "V0RapidityAntiLambda"); xSec->SetBinLabel(V0ProperLifetimeAntiLambda, "V0ProperLifetimeAntiLambda"); + xSec->SetBinLabel(MassCutAntiLambda, "MassCutAntiLambda"); xSec->SetBinLabel(AllGamma, "AllGamma"); + xSec->SetBinLabel(V0RapidityGamma, "V0RapidityGamma"); + xSec->SetBinLabel(MassCutGamma, "MassCutGamma"); mySelectionPrim = myTrackSelection(); } @@ -419,6 +591,13 @@ struct DedxPidAnalysis { return true; } + // Momentum + template + float getMomentum(const T1& track) + { + return (momentumMode == TpcInnerParam) ? track.tpcInnerParam() : track.p(); + }; + // General V0 Selections template bool passedV0Selection(const T1& v0, const C& /*collision*/) @@ -451,13 +630,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (v0SelectionMode == v0TPC) { + if (v0SelectionMode == V0TPC) { sigmap = ptrack.tpcNSigmaPi(); sigman = ntrack.tpcNSigmaPi(); - } else if (v0SelectionMode == v0TOF) { + } else if (v0SelectionMode == V0TOF) { sigmap = ptrack.tofNSigmaPi(); sigman = ntrack.tofNSigmaPi(); - } else if (v0SelectionMode == v0TPCTOF) { + } else if (v0SelectionMode == V0TPCTOF) { sigmap = std::hypot(ptrack.tpcNSigmaPi(), ptrack.tofNSigmaPi()); sigman = std::hypot(ntrack.tpcNSigmaPi(), ntrack.tofNSigmaPi()); } @@ -475,10 +654,25 @@ struct DedxPidAnalysis { if (std::abs(sigman) > nsigmaTOFmax) return false; } + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllK0s); - // Invariant-Mass Selection - if (v0.mK0Short() < minMassK0s || v0.mK0Short() > maxMassK0s) + if (std::abs(v0.yK0Short()) > v0rapidityCut) return false; + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityK0s); + + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassK0Short; + + if (properLifetime > v0ProperLifetimeCutK0s) + return false; + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeK0s); + + if (std::abs(v0.mK0Short() - MassK0Short) > invMassCutK0s) + return false; + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::MassCutK0s); return true; } @@ -497,13 +691,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (v0SelectionMode == v0TPC) { + if (v0SelectionMode == V0TPC) { sigmap = ptrack.tpcNSigmaPr(); sigman = ntrack.tpcNSigmaPi(); - } else if (v0SelectionMode == v0TOF) { + } else if (v0SelectionMode == V0TOF) { sigmap = ptrack.tofNSigmaPr(); sigman = ntrack.tofNSigmaPi(); - } else if (v0SelectionMode == v0TPCTOF) { + } else if (v0SelectionMode == V0TPCTOF) { sigmap = std::hypot(ptrack.tpcNSigmaPr(), ptrack.tofNSigmaPr()); sigman = std::hypot(ntrack.tpcNSigmaPi(), ntrack.tofNSigmaPi()); } @@ -521,10 +715,27 @@ struct DedxPidAnalysis { if (std::abs(sigman) > nsigmaTOFmax) return false; } + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllLambda); - // Invariant-Mass Selection - if (v0.mLambda() < minMassLambda || v0.mLambda() > maxMassLambda) + if (std::abs(v0.yLambda()) > v0rapidityCut) return false; + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityLambda); + + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassLambda; + + if (properLifetime > v0ProperLifetimeCutLambda) + return false; + + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeLambda); + + if (std::abs(v0.mLambda() - MassLambda) > invMassCutLambda) { + return false; + } + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::MassCutLambda); return true; } @@ -543,13 +754,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (v0SelectionMode == v0TPC) { + if (v0SelectionMode == V0TPC) { sigmap = ptrack.tpcNSigmaPi(); sigman = ntrack.tpcNSigmaPr(); - } else if (v0SelectionMode == v0TOF) { + } else if (v0SelectionMode == V0TOF) { sigmap = ptrack.tofNSigmaPi(); sigman = ntrack.tofNSigmaPr(); - } else if (v0SelectionMode == v0TPCTOF) { + } else if (v0SelectionMode == V0TPCTOF) { sigmap = std::hypot(ptrack.tpcNSigmaPi(), ptrack.tofNSigmaPi()); sigman = std::hypot(ntrack.tpcNSigmaPr(), ntrack.tofNSigmaPr()); } @@ -566,11 +777,29 @@ struct DedxPidAnalysis { if (std::abs(sigman) > nsigmaTOFmax) return false; } + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllAntiLambda); + + if (std::abs(v0.yLambda()) > v0rapidityCut) + return false; + + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityAntiLambda); + + float properLifetime = v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * MassLambda; - // Invariant-Mass Selection - if (v0.mAntiLambda() < minMassLambda || v0.mAntiLambda() > maxMassLambda) + if (properLifetime > v0ProperLifetimeCutLambda) return false; + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0ProperLifetimeAntiLambda); + + if (std::abs(v0.mAntiLambda() - MassLambda) > invMassCutLambda) + return false; + + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::MassCutAntiLambda); + return true; } @@ -588,13 +817,13 @@ struct DedxPidAnalysis { double sigmap = 0.0; double sigman = 0.0; - if (v0SelectionMode == v0TPC) { + if (v0SelectionMode == V0TPC) { sigmap = ptrack.tpcNSigmaEl(); sigman = ntrack.tpcNSigmaEl(); - } else if (v0SelectionMode == v0TOF) { + } else if (v0SelectionMode == V0TOF) { sigmap = ptrack.tofNSigmaEl(); sigman = ntrack.tofNSigmaEl(); - } else if (v0SelectionMode == v0TPCTOF) { + } else if (v0SelectionMode == V0TPCTOF) { sigmap = std::hypot(ptrack.tpcNSigmaEl(), ptrack.tofNSigmaEl()); sigman = std::hypot(ntrack.tpcNSigmaEl(), ntrack.tofNSigmaEl()); } @@ -612,11 +841,25 @@ struct DedxPidAnalysis { if (std::abs(sigman) > nsigmaTOFmax) return false; } + const float gammaMass = 2 * MassElectron; // GeV/c^2 + + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllGamma); - // Invariant-Mass Selection - if (v0.mGamma() < minMassGamma || v0.mGamma() > maxMassGamma) + const float yGamma = RecoDecay::y(std::array{v0.px(), v0.py(), v0.pz()}, MassGamma); + + if (std::abs(yGamma) > v0rapidityCut) + return false; + + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0RapidityGamma); + + if (std::abs(v0.mGamma() - gammaMass) > invMassCutGamma) return false; + if (fillHist) + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::MassCutGamma); + return true; } // Magnetic field @@ -637,12 +880,12 @@ struct DedxPidAnalysis { template bool passedPhiCutPri(const T& trk, float magField, const TF1& fphiCutLow, const TF1& fphiCutHigh) { - float p = trk.pt(); + float p = trk.p(); float pt = trk.pt(); float phi = trk.phi(); int charge = trk.sign(); - float eta = trk.eta(); auto nTPCCl = trk.tpcNClsFound(); + auto nTPCPIDCl = trk.tpcNClsPID(); if (pt < pTcut) return true; @@ -656,72 +899,74 @@ 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_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); + registryDeDx.fill(HIST("hpt_vs_phi_NclFound_TPC_Before"), pt, phi, nTPCCl); + registryDeDx.fill(HIST("hp_vs_phi_NclFound_TPC_Before"), p, phi, nTPCCl); + registryDeDx.fill(HIST("hpt_vs_phi_NclPID_TPC_Before"), pt, phi, nTPCPIDCl); + registryDeDx.fill(HIST("hp_vs_phi_NclPID_TPC_Before"), p, phi, nTPCPIDCl); // 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); + registryDeDx.fill(HIST("hpt_vs_phi_NclFound_TPC_After"), pt, phi, nTPCCl); + registryDeDx.fill(HIST("hp_vs_phi_NclFound_TPC_After"), p, phi, nTPCCl); + registryDeDx.fill(HIST("hpt_vs_phi_NclPID_TPC_After"), pt, phi, nTPCPIDCl); + registryDeDx.fill(HIST("hp_vs_phi_NclPID_TPC_After"), p, phi, nTPCPIDCl); return true; } // NclCutTPC template - bool passedNTPCClCutPri(const T& trk) + bool passedNClTPCFoundCutPri(const T& trk) { float eta = trk.eta(); - float sigP = trk.sign() * trk.tpcInnerParam(); + float sigP = trk.sign() * getMomentum(trk); auto nTPCCl = trk.tpcNClsFound(); - if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (eta >= EtaCut[0] && eta < EtaCut[1]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[0]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + } else if (eta >= EtaCut[1] && eta < EtaCut[2]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[1]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + } else if (eta >= EtaCut[2] && eta < EtaCut[3]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[2]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + } else if (eta >= EtaCut[3] && eta < EtaCut[4]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[3]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + } else if (eta >= EtaCut[4] && eta < EtaCut[5]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[4]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + } else if (eta >= EtaCut[5] && eta < EtaCut[6]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[5]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + } else if (eta >= EtaCut[6] && eta < EtaCut[7]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { registryDeDx.fill(HIST(kNclTPCDedxMomentumPosBefore[6]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + } else if (eta >= EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegBefore[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { @@ -732,49 +977,49 @@ struct DedxPidAnalysis { if (nTPCCl < minTPCnClsFound) return false; - if (eta > EtaCut[0] && eta < EtaCut[1]) { + 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]) { + } 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]) { + } 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]) { + } 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]) { + } 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]) { + } 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]) { + } 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]) { + } else if (eta >= EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { registryDeDx.fill(HIST(kNclTPCDedxMomentumNegAfter[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { @@ -785,114 +1030,114 @@ struct DedxPidAnalysis { return true; } - // NclCutITS + // NclPIDCutTPC template - bool passedNITSClCutPri(const T& trk) + bool passedNClTPCPIDCutPri(const T& trk) { float eta = trk.eta(); - float sigP = trk.sign() * trk.tpcInnerParam(); - auto nITSCl = trk.itsNCls(); + float sigP = trk.sign() * getMomentum(trk); + auto nTPCCl = trk.tpcNClsPID(); - if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (eta >= EtaCut[0] && eta < EtaCut[1]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[0]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[0]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[0]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + } else if (eta >= EtaCut[1] && eta < EtaCut[2]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[1]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[1]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[1]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + } else if (eta >= EtaCut[2] && eta < EtaCut[3]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[2]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[2]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[2]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + } else if (eta >= EtaCut[3] && eta < EtaCut[4]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[3]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[3]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[3]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + } else if (eta >= EtaCut[4] && eta < EtaCut[5]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[4]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[4]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[4]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + } else if (eta >= EtaCut[5] && eta < EtaCut[6]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[5]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[5]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[5]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + } else if (eta >= EtaCut[6] && eta < EtaCut[7]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[6]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[6]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[6]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + } else if (eta >= EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegBefore[7]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegBefore[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosBefore[7]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosBefore[7]), nTPCCl, trk.tpcSignal(), sigP); } } - if (nITSCl < minITSnCls) + if (nTPCCl < minTPCnClsPID) return false; - if (eta > EtaCut[0] && eta < EtaCut[1]) { + if (eta >= EtaCut[0] && eta < EtaCut[1]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[0]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[0]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[0]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[0]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[1] && eta < EtaCut[2]) { + } else if (eta >= EtaCut[1] && eta < EtaCut[2]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[1]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[1]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[1]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[1]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[2] && eta < EtaCut[3]) { + } else if (eta >= EtaCut[2] && eta < EtaCut[3]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[2]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[2]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[2]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[2]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[3] && eta < EtaCut[4]) { + } else if (eta >= EtaCut[3] && eta < EtaCut[4]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[3]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[3]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[3]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[3]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[4] && eta < EtaCut[5]) { + } else if (eta >= EtaCut[4] && eta < EtaCut[5]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[4]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[4]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[4]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[4]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[5] && eta < EtaCut[6]) { + } else if (eta >= EtaCut[5] && eta < EtaCut[6]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[5]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[5]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[5]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[5]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[6] && eta < EtaCut[7]) { + } else if (eta >= EtaCut[6] && eta < EtaCut[7]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[6]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[6]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[6]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[6]), nTPCCl, trk.tpcSignal(), sigP); } - } else if (eta > EtaCut[7] && eta < EtaCut[8]) { + } else if (eta >= EtaCut[7] && eta < EtaCut[8]) { if (sigP < 0) { - registryDeDx.fill(HIST(kNclITSDedxMomentumNegAfter[7]), nITSCl, trk.tpcSignal(), std::abs(sigP)); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumNegAfter[7]), nTPCCl, trk.tpcSignal(), std::abs(sigP)); } else { - registryDeDx.fill(HIST(kNclITSDedxMomentumPosAfter[7]), nITSCl, trk.tpcSignal(), sigP); + registryDeDx.fill(HIST(kNclPIDTPCDedxMomentumPosAfter[7]), nTPCCl, trk.tpcSignal(), sigP); } } @@ -928,7 +1173,7 @@ struct DedxPidAnalysis { // NclCutTPC template - bool passedNTPCClCutSecondaries(const T& trk) + bool passedNClTPCFoundCutSecondaries(const T& trk) { auto nTPCCl = trk.tpcNClsFound(); @@ -938,13 +1183,13 @@ struct DedxPidAnalysis { return true; } - // NclCutITS primary + // NclCutPIDTPC secondary template - bool passedNITSClCutSecondaries(const T& trk) + bool passedNClTPCPIDCutSecondaries(const T& trk) { - auto nITSCl = trk.itsNCls(); + auto nTPCCl = trk.tpcNClsPID(); - if (nITSCl < minITSnCls) + if (nTPCCl < minTPCnClsPID) return false; return true; @@ -984,6 +1229,10 @@ struct DedxPidAnalysis { const uint64_t timeStamp{foundBC.timestamp()}; const int magField{getMagneticField(timeStamp)}; + float centrality = collision.centFT0C(); + if (centrality < CentClasses[0] || centrality > CentClasses[10]) + return; + for (const auto& trk : tracks) { registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::AllPri); // track Selection @@ -998,24 +1247,29 @@ struct DedxPidAnalysis { continue; } registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::PhiVarCutPri); - // NCl cut ITS - if (nTPCClCut) { - if (!passedNTPCClCutPri(trk)) + + // NCl cut TPC + registryDeDx.fill(HIST("heta_vs_NclFound_TPC_Before_Primary"), trk.eta(), trk.tpcNClsFound()); + if (nClTPCFoundCut) { + if (!passedNClTPCFoundCutPri(trk)) continue; } - registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NTPCClCutPri); + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NClTPCFoundCutPri); + registryDeDx.fill(HIST("heta_vs_NclFound_TPC_After_Primary"), trk.eta(), trk.tpcNClsFound()); - // NCl cut ITS - if (nITSClCut) { - if (!passedNITSClCutPri(trk)) + // NCl cut PID TPC + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_Primary"), trk.eta(), trk.tpcNClsPID()); + if (nClTPCPIDCut) { + if (!passedNClTPCPIDCutPri(trk)) continue; } - registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NITSClCutPri); + registryDeDx.fill(HIST("trackselAll"), TrkPriCutLabel::NClTPCPIDCutPri); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_Primary"), trk.eta(), trk.tpcNClsPID()); - float signedP = trk.sign() * trk.tpcInnerParam(); + float signedP = trk.sign() * getMomentum(trk); // MIP calibration for pions - if (trk.tpcInnerParam() >= pionMin && trk.tpcInnerParam() <= pionMax) { + if (getMomentum(trk) >= pionMin && getMomentum(trk) <= pionMax) { if (calibrationMode) { if (signedP < 0) { registryDeDx.fill(HIST("hdEdx_vs_eta_Neg_Pi"), trk.eta(), trk.tpcSignal()); @@ -1025,7 +1279,7 @@ struct DedxPidAnalysis { } else { for (int i = 0; i < kEtaIntervals; ++i) { - if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + 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 { @@ -1051,7 +1305,7 @@ struct DedxPidAnalysis { } } else { for (int i = 0; i < kEtaIntervals; ++i) { - if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + 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 { @@ -1071,7 +1325,7 @@ struct DedxPidAnalysis { } } else { for (int i = 0; i < kEtaIntervals; ++i) { - if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + 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 { @@ -1085,14 +1339,26 @@ struct DedxPidAnalysis { registryDeDx.fill(HIST("hdEdx_vs_phi"), trk.phi(), trk.tpcSignal()); if (!calibrationMode) { + int centIndex = -1; + for (int j = 0; j < kCentralityClasses; ++j) { + if (centrality >= CentClasses[j] && centrality < CentClasses[j + 1]) { + centIndex = j; + break; + } + } + if (centIndex == -1) + continue; + for (int i = 0; i < kEtaIntervals; ++i) { - if (trk.eta() > EtaCut[i] && trk.eta() < EtaCut[i + 1]) { + 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("heta_vs_p_vs_pt_all_Pos"), trk.eta(), trk.pt(), signedP); + registryDeDx.fill(HIST("heta_vs_pt_vs_p_all_Pos"), trk.eta(), trk.pt(), trk.p()); + hDedxVsMomentumVsCentPos[centIndex]->Fill(signedP, trk.tpcSignal() * 50 / calibrationFactorPos->at(i), trk.eta()); } else { registryDeDx.fill(HIST(kDedxvsMomentumNeg[0]), std::abs(signedP), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i), trk.eta()); - registryDeDx.fill(HIST("heta_vs_p_vs_pt_all_Neg"), trk.eta(), trk.pt(), std::abs(signedP)); + registryDeDx.fill(HIST("heta_vs_pt_vs_p_all_Neg"), trk.eta(), trk.pt(), trk.p()); + hDedxVsMomentumVsCentNeg[centIndex]->Fill(std::abs(signedP), trk.tpcSignal() * 50 / calibrationFactorNeg->at(i), trk.eta()); } } } @@ -1105,6 +1371,13 @@ struct DedxPidAnalysis { // Standard V0 Selections registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::AllSec); + + // Select V0 type + if (v0.v0Type() != v0TypeSelection) + continue; + + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel::V0Type); + if (!passedV0Selection(v0, collision)) { continue; } @@ -1129,63 +1402,67 @@ struct DedxPidAnalysis { } registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::PhiVarCutSec); - if (nTPCClCut) { - if (!passedNTPCClCutSecondaries(posTrack)) + fillHist = false; + // K0s Selection + if (passedK0Selection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_PionsK0s"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_PionsK0s"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_PionsK0s"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_PionsK0s"), negTrack.p(), negTrack.tpcNClsPID()); + } + // Lambda Selection + if (passedLambdaSelection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_ProtonsLambda"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_PionsLambda"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_ProtonsLambda"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_PionsLambda"), negTrack.p(), negTrack.tpcNClsPID()); + } + // AntiLambda Selection + if (passedAntiLambdaSelection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_PionsLambda"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_ProtonsLambda"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_PionsLambda"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_ProtonsLambda"), negTrack.p(), negTrack.tpcNClsPID()); + } + // Gamma Selection + if (passedGammaSelection(v0, negTrack, posTrack, collision)) { + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_ElectronsGamma"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_Before_ElectronsGamma"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_ElectronsGamma"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_Before_ElectronsGamma"), negTrack.p(), negTrack.tpcNClsPID()); + } + + if (nClTPCFoundCut) { + if (!passedNClTPCFoundCutSecondaries(posTrack)) continue; - if (!passedNTPCClCutSecondaries(negTrack)) + if (!passedNClTPCFoundCutSecondaries(negTrack)) continue; } - registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NTPCClCutSec); + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NClTPCFoundCutSec); - if (nITSClCut) { - if (!passedNITSClCutSecondaries(posTrack)) + if (nClTPCPIDCut) { + if (!passedNClTPCPIDCutSecondaries(posTrack)) continue; - if (!passedNITSClCutSecondaries(negTrack)) + if (!passedNClTPCPIDCutSecondaries(negTrack)) continue; } - registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NITSClCutSec); - - float signedPpos = posTrack.sign() * posTrack.tpcInnerParam(); - float signedPneg = negTrack.sign() * negTrack.tpcInnerParam(); - - float pxPos = posTrack.px(); - float pyPos = posTrack.py(); - float pzPos = posTrack.pz(); + registryDeDx.fill(HIST("trackselSec"), TrkSecCutLabel ::NClTPCPIDCutSec); - float pxNeg = negTrack.px(); - float pyNeg = negTrack.py(); - float pzNeg = negTrack.pz(); + float signedPpos = posTrack.sign() * getMomentum(posTrack); + float signedPneg = negTrack.sign() * getMomentum(negTrack); - const float gammaMass = 2 * MassElectron; // GeV/c^2 + fillHist = true; // 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); - - 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; - } - + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_PionsK0s"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_PionsK0s"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_PionsK0s"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_PionsK0s"), negTrack.p(), negTrack.tpcNClsPID()); 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()); @@ -1198,28 +1475,10 @@ 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); - - 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; - } - + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_ProtonsLambda"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_PionsLambda"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_ProtonsLambda"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_PionsLambda"), negTrack.p(), negTrack.tpcNClsPID()); 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()); @@ -1232,28 +1491,10 @@ 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); - - 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; - } - + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_PionsLambda"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_ProtonsLambda"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_PionsLambda"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_ProtonsLambda"), negTrack.p(), negTrack.tpcNClsPID()); 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()); @@ -1266,17 +1507,10 @@ 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); - - 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; - } - + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_ElectronsGamma"), posTrack.eta(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("heta_vs_NclPID_TPC_After_ElectronsGamma"), negTrack.eta(), negTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_ElectronsGamma"), posTrack.p(), posTrack.tpcNClsPID()); + registryDeDx.fill(HIST("hp_vs_NclPID_TPC_After_ElectronsGamma"), negTrack.p(), negTrack.tpcNClsPID()); 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());