From 3573af906b884a0f8958a24ee5f59b75c658d463 Mon Sep 17 00:00:00 2001 From: Soumyadip Ghosh Date: Sat, 7 Nov 2026 23:50:52 +0530 Subject: [PATCH 1/5] Update longrangecorrDerived.cxx --- .../Tasks/longrangecorrDerived.cxx | 609 ++++++++++-------- 1 file changed, 336 insertions(+), 273 deletions(-) diff --git a/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx b/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx index 9745762a695..805e03a250f 100644 --- a/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx +++ b/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx @@ -17,20 +17,24 @@ #include "PWGCF/Core/CorrelationContainer.h" #include "PWGCF/TwoParticleCorrelations/DataModel/LongRangeDerived.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" #include "PWGUD/Core/SGSelector.h" #include "Common/CCDB/EventSelectionParams.h" #include "Common/Core/RecoDecay.h" #include "Common/Core/TrackSelection.h" #include "Common/Core/TrackSelectionDefaults.h" +#include "Common/DataModel/Centrality.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/McCollisionExtra.h" +#include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/PIDResponseTOF.h" #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/TrackSelectionTables.h" #include #include +#include #include #include #include @@ -91,6 +95,8 @@ struct LongrangecorrDerived { Configurable cfgEtaCut{"cfgEtaCut", 0.8f, "Eta range to consider"}; Configurable cfgPtCutMin{"cfgPtCutMin", 0.2f, "minimum accepted track pT"}; Configurable cfgPtCutMax{"cfgPtCutMax", 10.0f, "maximum accepted track pT"}; + Configurable cfgPtCutMinForMult{"cfgPtCutMinForMult", 0.2f, "minimum track pT for fallback multiplicity classification"}; + Configurable cfgPtCutMaxForMult{"cfgPtCutMaxForMult", 3.0f, "maximum track pT for fallback multiplicity classification"}; Configurable cfgTpcMinNclsFound{"cfgTpcMinNclsFound", 50.0f, ""}; Configurable cfgTpcMinNCrossedRows{"cfgTpcMinNCrossedRows", 70.0f, ""}; Configurable cfgTpcMaxChi2PerCluster{"cfgTpcMaxChi2PerCluster", 4.0f, ""}; @@ -100,13 +106,6 @@ struct LongrangecorrDerived { Configurable cfgEffccdbPath{"cfgEffccdbPath", "Users/a/abmodak/Efficiency/OO/default", "Browse track eff object from CCDB"}; Configurable cfgAccccdbPath{"cfgAccccdbPath", "Users/a/abmodak/Acceptance/OO/default", "Browse track eff object from CCDB"}; - Configurable cfgMftCluster{"cfgMftCluster", 5, "cut on MFT Cluster"}; - Configurable cfgMftDcaxy{"cfgMftDcaxy", 2.0f, "cut on DCA xy for MFT tracks"}; - Configurable cfgMftDcaz{"cfgMftDcaz", 2.0f, "cut on DCA z for MFT tracks"}; - Configurable cfgRejectAmbTrk{"cfgRejectAmbTrk", false, "Condition to reject Ambiguous tracks"}; - Configurable cfgRejectNonAmbTrk{"cfgRejectNonAmbTrk", false, "Condition to reject Non-Ambiguous tracks"}; - Configurable cfgRequireCA{"cfgRequireCA", false, "Use Cellular Automaton track-finding algorithm"}; - Configurable cfgRequireLTF{"cfgRequireLTF", false, "Use LTF track-finding algorithm"}; Configurable cfgRequireFt0aOuterRing{"cfgRequireFt0aOuterRing", false, "Consider FT0A Outer Ring"}; Configurable cfgRequireFt0aInnerRing{"cfgRequireFt0aInnerRing", false, "Consider FT0A Inner Ring"}; Configurable cfgRequireFt0cOuterRing{"cfgRequireFt0cOuterRing", false, "Consider FT0C Outer Ring"}; @@ -115,13 +114,37 @@ struct LongrangecorrDerived { Configurable cfgTofPidPtCut{"cfgTofPidPtCut", 0.4f, "Minimum pt to use TOF N-sigma"}; Configurable cfgPidNsigmaMax{"cfgPidNsigmaMax", 1.5f, "Maximum n-sigma for PID"}; Configurable cfgPidNsigmaMin{"cfgPidNsigmaMin", -1.5f, "Minimum n-sigma for PID"}; - Configurable cfgCleanNsigmaTpcMax{"cfgCleanNsigmaTpcMax", 1.5f, "Max TPC n-sigma for clean templates"}; - Configurable cfgCleanNsigmaTpcMin{"cfgCleanNsigmaTpcMin", -1.5f, "Min TPC n-sigma for clean templates"}; + Configurable cfgCleanNsigmaTpcMax{"cfgCleanNsigmaTpcMax", 10.0f, "Max TPC n-sigma for clean templates (wide to avoid dE/dx truncation)"}; + Configurable cfgCleanNsigmaTpcMin{"cfgCleanNsigmaTpcMin", -10.0f, "Min TPC n-sigma for clean templates (wide to avoid dE/dx truncation)"}; Configurable cfgCleanNsigmaTofMax{"cfgCleanNsigmaTofMax", 1.5f, "Max TOF n-sigma for clean templates"}; Configurable cfgCleanNsigmaTofMin{"cfgCleanNsigmaTofMin", -1.5f, "Min TOF n-sigma for clean templates"}; + Configurable cfgCleanTofVetoNsigma{"cfgCleanTofVetoNsigma", 3.0f, "Veto other species within this |nSigmaTOF| for track-level TOF-clean templates"}; Configurable cfgGetNsigmaQA{"cfgGetNsigmaQA", true, "Get QA histograms for PID selection"}; Configurable cfgGetdEdx{"cfgGetdEdx", true, "Get dEdx histograms for TPC signal"}; - + Configurable cfgGetAllSpeciesQA{"cfgGetAllSpeciesQA", true, "Fill unified all-species dE/dx and expected sigma histograms"}; + Configurable cfgGetV0CleanSample{"cfgGetV0CleanSample", true, "Fill clean V0 daughter (K0s -> pi pi, Lambda -> p pi) dE/dx templates"}; + Configurable cfgFillAfterCutWithV0{"cfgFillAfterCutWithV0", true, "Fill TpcdEdx_ptwise_afterCut and TofTpcNsigma_after for pi and p using V0 clean daughters"}; + Configurable cfgRequireTofForV0AfterCut{"cfgRequireTofForV0AfterCut", true, "Require hasTOF and |nSigmaTOF| < cfgCleanNsigmaTofMax when filling afterCut from V0s"}; + Configurable cfgIncludeLambdaPiInCleanPi{"cfgIncludeLambdaPiInCleanPi", true, "Also include clean pions from Lambda -> p pi in TpcdEdx_ptwise_afterCut for pion wagon"}; + Configurable cfgAllowFallbackMultInPIDQA{"cfgAllowFallbackMultInPIDQA", false, "If true and LRCollisions is empty, use fallback multiplicity in processPIDQA"}; + Configurable cfgRequireTofInMCdEdx{"cfgRequireTofInMCdEdx", true, "Require hasTOF and |nSigmaTOF| < 1.5 in MC_TpcdEdx_ptwise"}; + + // V0 topological cuts for clean daughter template extraction (tag-and-probe without TPC cut on probe daughter) + Configurable cfgCleanV0MinCosPA{"cfgCleanV0MinCosPA", 0.995f, "Min cos(PA) for clean V0 daughters"}; + Configurable cfgCleanV0MaxDcaDau{"cfgCleanV0MaxDcaDau", 0.8f, "Max DCA between V0 daughters (cm)"}; + Configurable cfgCleanV0MinRadius{"cfgCleanV0MinRadius", 1.2f, "Min V0 2D decay radius (cm)"}; + Configurable cfgCleanV0MaxRadius{"cfgCleanV0MaxRadius", 30.0f, "Max V0 2D decay radius (cm)"}; + Configurable cfgCleanK0sMassWin{"cfgCleanK0sMassWin", 0.008f, "Tight K0s mass window around PDG mass (GeV/c^2)"}; + Configurable cfgCleanK0sMinArmQt{"cfgCleanK0sMinArmQt", 0.2f, "Min Armenteros qT/|alpha| for clean K0s"}; + Configurable cfgCleanK0sMaxCtau{"cfgCleanK0sMaxCtau", 20.0f, "Max proper lifetime c*tau for clean K0s (cm)"}; + Configurable cfgCleanK0sMinDcaToPv{"cfgCleanK0sMinDcaToPv", 0.1f, "Min pion DCA to PV for clean K0s (cm)"}; + Configurable cfgCleanLambdaMassWin{"cfgCleanLambdaMassWin", 0.005f, "Tight Lambda mass window around PDG mass (GeV/c^2)"}; + Configurable cfgCleanLambdaRejK0sWin{"cfgCleanLambdaRejK0sWin", 0.012f, "Competing K0s mass rejection window for clean Lambda (GeV/c^2)"}; + Configurable cfgCleanLambdaMinArmQt{"cfgCleanLambdaMinArmQt", 0.02f, "Min Armenteros qT for clean Lambda to reject photon conversions (GeV/c)"}; + Configurable cfgCleanLambdaMaxCtau{"cfgCleanLambdaMaxCtau", 30.0f, "Max proper lifetime c*tau for clean Lambda (cm)"}; + Configurable cfgCleanLambdaMinDcaPr{"cfgCleanLambdaMinDcaPr", 0.07f, "Min proton DCA to PV for clean Lambda (cm)"}; + Configurable cfgCleanLambdaMinDcaPi{"cfgCleanLambdaMinDcaPi", 0.2f, "Min pion DCA to PV for clean Lambda (cm)"}; + Configurable cfgCleanV0TagTpcNsigma{"cfgCleanV0TagTpcNsigma", 3.0f, "Max |nSigmaTPC| on companion tag daughter"}; } cfgSel; struct : ConfigurableGroup { @@ -132,7 +155,7 @@ struct LongrangecorrDerived { ConfigurableAxis axisPhi{"axisPhi", {96, 0, TwoPI}, "#phi axis"}; ConfigurableAxis axisEtaTrig{"axisEtaTrig", {40, -1., 1.}, "#eta trig axis"}; ConfigurableAxis axisPtTrigger{"axisPtTrigger", {VARIABLE_WIDTH, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 6.0, 10.0}, "pt trigger axis for histograms"}; - ConfigurableAxis axisPtQA{"axisPtQA", {50, 0.0, 8.0}, "pt axis for PID QA histograms"}; + ConfigurableAxis axisPtQA{"axisPtQA", {80, 0.0, 8.0}, "pt axis for PID QA histograms"}; ConfigurableAxis axisVtxZ{"axisVtxZ", {40, -20, 20}, "vertex axis"}; ConfigurableAxis axisEtaAssoc{"axisEtaAssoc", {96, 3.5, 4.9}, "#eta assoc axis"}; @@ -151,11 +174,6 @@ struct LongrangecorrDerived { ConfigurableAxis axisTPCChi2NCl{"axisTPCChi2NCl", {20, 0.0, 20.0}, "TPC Chi2/NCl axis"}; ConfigurableAxis axisTPCdcaZ{"axisTPCdcaZ", {200, -10.0, 10.0}, "TPC dcaZ axis"}; - ConfigurableAxis axisMFTAmbDegree{"axisMFTAmbDegree", {50, -0.5, 49.5}, "Track Ambiguity axis"}; - ConfigurableAxis axisMFTNClusters{"axisMFTNClusters", {200, -0.5, 199.5}, "MFT Cluster axis"}; - ConfigurableAxis axisMFTbestDCAXY{"axisMFTbestDCAXY", {200, -10.0, 10.0}, "MFT dcaXY axis"}; - ConfigurableAxis axisMFTbestDCAZ{"axisMFTbestDCAZ", {200, -10.0, 10.0}, "MFT dcaZ axis"}; - ConfigurableAxis axisVertexEfficiency{"axisVertexEfficiency", {10, -10, 10}, "vertex axis for efficiency histograms"}; ConfigurableAxis axisEtaEfficiency{"axisEtaEfficiency", {20, -1.0, 1.0}, "eta axis for efficiency histograms"}; ConfigurableAxis axisPtEfficiency{"axisPtEfficiency", {1, 0.5, 8.0}, "pt axis for efficiency histograms"}; @@ -163,6 +181,7 @@ struct LongrangecorrDerived { ConfigurableAxis axisNsigmaTPC{"axisNsigmaTPC", {80, -5, 5}, "nsigmaTPC axis"}; ConfigurableAxis axisNsigmaTOF{"axisNsigmaTOF", {80, -5, 5}, "nsigmaTOF axis"}; ConfigurableAxis axisTpcSignal{"axisTpcSignal", {250, 0, 250}, "dEdx axis for TPC"}; + ConfigurableAxis axisTpcExpSigma{"axisTpcExpSigma", {200, 0, 20}, "Expected sigma axis for TPC dE/dx"}; ConfigurableAxis axisMcPt{"axisMcPt", {100, 0.2, 10.0}, "p_{T} (GeV/c)"}; ConfigurableAxis axisMcEta{"axisMcEta", {100, -0.8, 0.8}, "#eta"}; @@ -185,38 +204,32 @@ struct LongrangecorrDerived { using CollsTable = aod::LRCollisions; using TrksTable = aod::LRMidTracks; - using MftTrksTable = aod::LRMftTracks; using Ft0aTrksTable = aod::LRFt0aTracks; using Ft0cTrksTable = aod::LRFt0cTracks; using V0TrksTable = aod::LRV0Tracks; using McCollsTable = aod::LRMcCollisions; using McTrksTable = aod::LRMidMcTracks; - using McMftTrksTable = aod::LRMftMcTracks; using McFt0aTrksTable = aod::LRFt0aMcTracks; using McFt0cTrksTable = aod::LRFt0cMcTracks; using UpcCollsTable = soa::Join; using TrksUpcTable = aod::UpcLRMidTracks; - using MftTrksUpcTable = aod::UpcLRMftTracks; using Ft0aTrksUpcTable = aod::UpcLRFt0aTracks; using Ft0cTrksUpcTable = aod::UpcLRFt0cTracks; using V0TrksUpcTable = aod::UpcLRV0Tracks; Preslice perColTpc = aod::lrcorrtrktable::lrCollisionId; - Preslice perColMft = aod::lrcorrtrktable::lrCollisionId; Preslice perColFt0a = aod::lrcorrtrktable::lrCollisionId; Preslice perColFt0c = aod::lrcorrtrktable::lrCollisionId; Preslice perColV0 = aod::lrcorrtrktable::lrCollisionId; Preslice perUpcColTpc = aod::lrcorrtrktable::upcLRCollisionId; - Preslice perUpcColMft = aod::lrcorrtrktable::upcLRCollisionId; Preslice perUpcColFt0a = aod::lrcorrtrktable::upcLRCollisionId; Preslice perUpcColFt0c = aod::lrcorrtrktable::upcLRCollisionId; Preslice perUpcColV0 = aod::lrcorrtrktable::upcLRCollisionId; Preslice perMcColTpc = aod::lrcorrmctrktable::lrMcCollisionId; - Preslice perMcColMft = aod::lrcorrmctrktable::lrMcCollisionId; Preslice perMcColFt0a = aod::lrcorrmctrktable::lrMcCollisionId; Preslice perMcColFt0c = aod::lrcorrmctrktable::lrMcCollisionId; @@ -271,13 +284,6 @@ struct LongrangecorrDerived { histos.add("TPCNClsCrossedRows", "TPCNClsCrossedRows", kTH1D, {cfgAxis.axisTPCNClsCrossedRows}); histos.add("TPCChi2NCl", "TPCChi2NCl", kTH1D, {cfgAxis.axisTPCChi2NCl}); histos.add("TPCdcaZ", "TPCdcaZ", kTH1D, {cfgAxis.axisTPCdcaZ}); - - histos.add("MFTNClusters", "MFTNClusters", kTH1D, {cfgAxis.axisMFTNClusters}); - histos.add("MFTbestDCAXY", "MFTbestDCAXY", kTH1D, {cfgAxis.axisMFTbestDCAXY}); - histos.add("MFTbestDCAZ", "MFTbestDCAZ", kTH1D, {cfgAxis.axisMFTbestDCAZ}); - - histos.add("ReassignedMFTtrackAmbDegree", "ReassignedMFTtrackAmbDegree", kTH1D, {cfgAxis.axisMFTAmbDegree}); - histos.add("AssignedMFTtrackAmbDegree", "AssignedMFTtrackAmbDegree", kTH1D, {cfgAxis.axisMFTAmbDegree}); } if (doprocessTPCtrackEff) { @@ -290,7 +296,12 @@ struct LongrangecorrDerived { } if (cfgSel.cfgGetdEdx) { - histos.add("MC_TpcdEdx_ptwise", "MC True TPC dE/dx;Particle Species;p_{T} (GeV/c);TPC dE/dx", kTHnSparseD, {{3, 0.5, 3.5}, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal}); + histos.add("MC_TpcdEdx_ptwise", "MC True TPC dE/dx;Particle Species;p_{T} (GeV/c);TPC dE/dx", + kTHnSparseD, {{3, 0.5, 3.5}, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal}); + histos.add("MC_TpcdEdx_TofNsigma_ptwise", "MC True TPC dE/dx vs TOF n#sigma;Particle Species;p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", + kTHnSparseD, {{3, 0.5, 3.5}, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); + histos.add("MC_ExpSigma_ptwise", "MC Expected TPC #sigma;Particle Species;p_{T} (GeV/c);#sigma_{exp}^{TPC};n#sigma_{TOF}", + kTHnSparseD, {{3, 0.5, 3.5}, cfgAxis.axisPtQA, cfgAxis.axisTpcExpSigma, cfgAxis.axisNsigmaTOF}); } } @@ -304,36 +315,62 @@ struct LongrangecorrDerived { myTrackFilter.SetMaxDcaZ(cfgSel.cfgTpcMaxDcaZ); myTrackFilter.print(); - if (cfgSel.cfgGetNsigmaQA && (cfgSel.cfgPidMask == KPidMaskPion || cfgSel.cfgPidMask == KPidMaskKaon || cfgSel.cfgPidMask == KPidMaskProton)) { + if (doprocessPIDQA) { + const AxisSpec axisEvtClass = cfgSel.isUseCentEst ? AxisSpec{cfgAxis.axisCentrality, "Centrality (%)"} + : AxisSpec{cfgAxis.axisMultiplicity, "Multiplicity (N_{ch})"}; + const AxisSpec axisSpecies{3, 0.5, 3.5, "Particle Species (1=#pi, 2=K, 3=p)"}; + const AxisSpec axisV0CleanType{3, 0.5, 3.5, "V0 Clean Daughter (1=#pi from K_{S}^{0}, 2=p from #Lambda, 3=#pi from #Lambda)"}; + + histos.add("hPIDQA_EventCount", "PIDQA Event Matching Counter;;Events", kTH1D, {{4, 0.5, 4.5}}); + histos.get(HIST("hPIDQA_EventCount"))->GetXaxis()->SetBinLabel(1, "Raw collisions"); + histos.get(HIST("hPIDQA_EventCount"))->GetXaxis()->SetBinLabel(2, "Pass basic EvSel"); + histos.get(HIST("hPIDQA_EventCount"))->GetXaxis()->SetBinLabel(3, "Matched to LRCollisions"); + histos.get(HIST("hPIDQA_EventCount"))->GetXaxis()->SetBinLabel(4, "Unmatched (skipped)"); - if (cfgSel.isUseCentEst) { // CENTRALITY MODE - histos.add("TofTpcNsigma_before", "TPC vs TOF n#sigma Before Cuts;Centrality (%);p_{T} (GeV/c);n#sigma_{TPC};n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisCentrality, cfgAxis.axisPtQA, cfgAxis.axisNsigmaTPC, cfgAxis.axisNsigmaTOF}); + if (cfgSel.cfgGetNsigmaQA && (cfgSel.cfgPidMask == KPidMaskPion || cfgSel.cfgPidMask == KPidMaskKaon || cfgSel.cfgPidMask == KPidMaskProton)) { + histos.add("TofTpcNsigma_before", "TPC vs TOF n#sigma Before Cuts;Event Class;p_{T} (GeV/c);n#sigma_{TPC};n#sigma_{TOF}", + kTHnSparseD, {axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisNsigmaTPC, cfgAxis.axisNsigmaTOF}); - histos.add("TofTpcNsigma_after", "TPC vs TOF n#sigma After Cuts;Centrality (%);p_{T} (GeV/c);n#sigma_{TPC};n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisCentrality, cfgAxis.axisPtQA, cfgAxis.axisNsigmaTPC, cfgAxis.axisNsigmaTOF}); + histos.add("TofTpcNsigma_after", "TPC vs TOF n#sigma After Cuts;Event Class;p_{T} (GeV/c);n#sigma_{TPC};n#sigma_{TOF}", + kTHnSparseD, {axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisNsigmaTPC, cfgAxis.axisNsigmaTOF}); if (cfgSel.cfgGetdEdx) { - histos.add("TpcdEdx_ptwise", "TPC dE/dx Before Cuts;Centrality (%);p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisCentrality, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); + histos.add("TpcdEdx_ptwise", "TPC dE/dx Before Cuts;Event Class;p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", + kTHnSparseD, {axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); + + histos.add("TpcdEdx_ptwise_afterCut", "TPC dE/dx After Clean TOF Cuts;Event Class;p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", + kTHnSparseD, {axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); - histos.add("TpcdEdx_ptwise_afterCut", "TPC dE/dx After Cuts;Centrality (%);p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisCentrality, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); + histos.add("ExpTpcdEdx_ptwise", "Expected TPC dE/dx;Event Class;p_{T} (GeV/c);Expected TPC dE/dx;n#sigma_{TOF}", + kTHnSparseD, {axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); + + histos.add("ExpSigma_ptwise", "Expected TPC #sigma;Event Class;p_{T} (GeV/c);#sigma_{exp}^{TPC};n#sigma_{TOF}", + kTHnSparseD, {axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcExpSigma, cfgAxis.axisNsigmaTOF}); } - } else { // MULTIPLICITY MODE - histos.add("TofTpcNsigma_before", "TPC vs TOF n#sigma Before Cuts;Multiplicity (N_{ch});p_{T} (GeV/c);n#sigma_{TPC};n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisMultiplicity, cfgAxis.axisPtQA, cfgAxis.axisNsigmaTPC, cfgAxis.axisNsigmaTOF}); + } - histos.add("TofTpcNsigma_after", "TPC vs TOF n#sigma After Cuts;Multiplicity (N_{ch});p_{T} (GeV/c);n#sigma_{TPC};n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisMultiplicity, cfgAxis.axisPtQA, cfgAxis.axisNsigmaTPC, cfgAxis.axisNsigmaTOF}); + if (cfgSel.cfgGetAllSpeciesQA && cfgSel.cfgGetdEdx) { + histos.add("TpcdEdx_allSpecies_ptwise", "All-Species TPC dE/dx;Species (1=#pi,2=K,3=p);Event Class;p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", + kTHnSparseD, {axisSpecies, axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); - if (cfgSel.cfgGetdEdx) { - histos.add("TpcdEdx_ptwise", "TPC dE/dx Before Cuts;Multiplicity (N_{ch});p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisMultiplicity, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); + histos.add("TpcdEdx_allSpecies_afterCut", "All-Species Clean TOF TPC dE/dx;Species (1=#pi,2=K,3=p);Event Class;p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", + kTHnSparseD, {axisSpecies, axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); - histos.add("TpcdEdx_ptwise_afterCut", "TPC dE/dx After Cuts;Multiplicity (N_{ch});p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", - kTHnSparseD, {cfgAxis.axisMultiplicity, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); - } + histos.add("ExpSigma_allSpecies_ptwise", "All-Species Expected TPC #sigma;Species (1=#pi,2=K,3=p);Event Class;p_{T} (GeV/c);#sigma_{exp}^{TPC};n#sigma_{TOF}", + kTHnSparseD, {axisSpecies, axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcExpSigma, cfgAxis.axisNsigmaTOF}); + } + + if (cfgSel.cfgGetV0CleanSample && cfgSel.cfgGetdEdx) { + histos.add("V0_TpcdEdx_ptwise", "Clean V0 Daughter TPC dE/dx;Daughter Type (1=#pi(K_{S}^{0}), 2=p(#Lambda), 3=#pi(#Lambda));Event Class;p_{T} (GeV/c);TPC dE/dx;n#sigma_{TOF}", + kTHnSparseD, {axisV0CleanType, axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcSignal, cfgAxis.axisNsigmaTOF}); + + histos.add("V0_ExpSigma_ptwise", "Clean V0 Daughter Expected TPC #sigma;Daughter Type (1=#pi(K_{S}^{0}), 2=p(#Lambda), 3=#pi(#Lambda));Event Class;p_{T} (GeV/c);#sigma_{exp}^{TPC};n#sigma_{TOF}", + kTHnSparseD, {axisV0CleanType, axisEvtClass, cfgAxis.axisPtQA, cfgAxis.axisTpcExpSigma, cfgAxis.axisNsigmaTOF}); + + histos.add("hCleanK0s_MassVsPt", "Selected Clean K_{S}^{0};p_{T} (GeV/c);M(#pi^{+}#pi^{-}) (GeV/c^{2})", + kTH2D, {cfgAxis.axisPtQA, {100, 0.45, 0.55}}); + histos.add("hCleanLambda_MassVsPt", "Selected Clean #Lambda/#bar{#Lambda};p_{T} (GeV/c);M(p#pi) (GeV/c^{2})", + kTH2D, {cfgAxis.axisPtQA, {100, 1.09, 1.14}}); } } } @@ -405,22 +442,6 @@ struct LongrangecorrDerived { if (std::abs(track.dcaZ()) > cfgSel.cfgTpcMaxDcaZ) return false; return true; - } else if constexpr (requires { track.nClusters(); }) { - if (track.nClusters() < cfgSel.cfgMftCluster) - return false; - if (std::abs(track.bestDCAXY()) >= cfgSel.cfgMftDcaxy) - return false; - if (std::abs(track.bestDCAZ()) >= cfgSel.cfgMftDcaz) - return false; - if (cfgSel.cfgRejectAmbTrk && track.ambDegree() > 1) - return false; - if (cfgSel.cfgRejectNonAmbTrk && track.ambDegree() == 1) - return false; - if (cfgSel.cfgRequireCA && !track.isCA()) - return false; - if (cfgSel.cfgRequireLTF && track.isCA()) - return false; - return true; } else { return true; } @@ -460,16 +481,6 @@ struct LongrangecorrDerived { histos.fill(HIST("TPCChi2NCl"), track.tpcChi2NCl()); histos.fill(HIST("TPCdcaZ"), track.dcaZ()); } - if constexpr (requires { track.nClusters(); }) { - histos.fill(HIST("MFTNClusters"), track.nClusters()); - histos.fill(HIST("MFTbestDCAXY"), track.bestDCAXY()); - histos.fill(HIST("MFTbestDCAZ"), track.bestDCAZ()); - if (track.isReassigned()) { - histos.fill(HIST("ReassignedMFTtrackAmbDegree"), track.ambDegree()); - } else { - histos.fill(HIST("AssignedMFTtrackAmbDegree"), track.ambDegree()); - } - } } template @@ -482,16 +493,6 @@ struct LongrangecorrDerived { histos.fill(HIST("Assoc_amp"), assoAmpl); histos.fill(HIST("Channel_vs_Assoc_amp"), track.channelID(), assoAmpl); } - if constexpr (requires { track.nClusters(); }) { - histos.fill(HIST("MFTNClusters"), track.nClusters()); - histos.fill(HIST("MFTbestDCAXY"), track.bestDCAXY()); - histos.fill(HIST("MFTbestDCAZ"), track.bestDCAZ()); - if (track.isReassigned()) { - histos.fill(HIST("ReassignedMFTtrackAmbDegree"), track.ambDegree()); - } else { - histos.fill(HIST("AssignedMFTtrackAmbDegree"), track.ambDegree()); - } - } } template @@ -648,7 +649,7 @@ struct LongrangecorrDerived { return multiplicity; }; using MixedBinning = FlexibleBinningPolicy, aod::collision::PosZ, decltype(getMultiplicity)>; - MixedBinning binningOnVtxAndMult{{getMultiplicity}, {cfgAxis.axisVtxZME, cfgAxis.axisMultME}}; + MixedBinning binningOnVtxAndMult{{getMultiplicity}, {cfgAxis.axisVtxZME, cfgAxis.axisMultME}, true}; auto tracksTuple = std::make_tuple(std::forward(tracks)...); using TupleAtrack = std::tuple_element<0, decltype(tracksTuple)>::type; using TupleBtrack = std::tuple_element - 1, decltype(tracksTuple)>::type; @@ -717,7 +718,7 @@ struct LongrangecorrDerived { }; using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getMultiplicity)>; - MixedBinning binningOnVtxAndMult{{getMultiplicity}, {cfgAxis.axisVtxZME, cfgAxis.axisMultME}}; + MixedBinning binningOnVtxAndMult{{getMultiplicity}, {cfgAxis.axisVtxZME, cfgAxis.axisMultME}, true}; auto tracksTuple = std::make_tuple(std::forward(tracks)...); using TupleAtrack = std::tuple_element<0, decltype(tracksTuple)>::type; using TupleBtrack = std::tuple_element - 1, decltype(tracksTuple)>::type; @@ -749,7 +750,7 @@ struct LongrangecorrDerived { return collision.multiplicity(); }; using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getMultiplicity)>; - MixedBinning binningOnVtxAndMult{{getMultiplicity}, {cfgAxis.axisVtxZME, cfgAxis.axisMultME}}; + MixedBinning binningOnVtxAndMult{{getMultiplicity}, {cfgAxis.axisVtxZME, cfgAxis.axisMultME}, true}; auto tracksTuple = std::make_tuple(std::forward(tracks)...); using TupleAtrack = std::tuple_element<0, decltype(tracksTuple)>::type; using TupleBtrack = std::tuple_element - 1, decltype(tracksTuple)>::type; @@ -772,16 +773,6 @@ struct LongrangecorrDerived { processSame(col, tracks, ft0cs); } - void processTpcmftSE(CollsTable::iterator const& col, TrksTable const& tracks, MftTrksTable const& mfts) - { - processSame(col, tracks, mfts); - } - - void processMftft0aSE(CollsTable::iterator const& col, MftTrksTable const& mfts, Ft0aTrksTable const& ft0as) - { - processSame(col, mfts, ft0as); - } - void processV0ft0aSE(CollsTable::iterator const& col, V0TrksTable const& tracks, Ft0aTrksTable const& ft0as) { processSame(col, tracks, ft0as); @@ -797,11 +788,6 @@ struct LongrangecorrDerived { processSame(col, v0s, tracks); } - void processV0mftSE(CollsTable::iterator const& col, V0TrksTable const& tracks, MftTrksTable const& mfts) - { - processSame(col, tracks, mfts); - } - void processFt0aft0cSE(CollsTable::iterator const& col, Ft0aTrksTable const& ft0as, Ft0cTrksTable const& ft0cs) { processSame(col, ft0as, ft0cs); @@ -817,16 +803,6 @@ struct LongrangecorrDerived { processMixed(cols, tracks, ft0cs); } - void processTpcmftME(CollsTable const& cols, TrksTable const& tracks, MftTrksTable const& mfts) - { - processMixed(cols, tracks, mfts); - } - - void processMftft0aME(CollsTable const& cols, MftTrksTable const& mfts, Ft0aTrksTable const& ft0as) - { - processMixed(cols, mfts, ft0as); - } - void processV0ft0aME(CollsTable const& cols, V0TrksTable const& tracks, Ft0aTrksTable const& ft0as) { processMixed(cols, tracks, ft0as); @@ -842,11 +818,6 @@ struct LongrangecorrDerived { processMixed(cols, v0s, tracks); } - void processV0mftME(CollsTable const& cols, V0TrksTable const& tracks, MftTrksTable const& mfts) - { - processMixed(cols, tracks, mfts); - } - void processFt0aft0cME(CollsTable const& cols, Ft0aTrksTable const& ft0as, Ft0cTrksTable const& ft0cs) { processMixed(cols, ft0as, ft0cs); @@ -868,22 +839,6 @@ struct LongrangecorrDerived { processSame(col, tracks, ft0cs); } - void processUpcTpcmftSE(UpcCollsTable::iterator const& col, TrksUpcTable const& tracks, MftTrksUpcTable const& mfts) - { - if (!isUpcEventSelected(col)) { - return; - } - processSame(col, tracks, mfts); - } - - void processUpcMftft0aSE(UpcCollsTable::iterator const& col, MftTrksUpcTable const& mfts, Ft0aTrksUpcTable const& ft0as) - { - if (!isUpcEventSelected(col)) { - return; - } - processSame(col, mfts, ft0as); - } - void processUpcV0ft0aSE(UpcCollsTable::iterator const& col, V0TrksUpcTable const& tracks, Ft0aTrksUpcTable const& ft0as) { if (!isUpcEventSelected(col)) { @@ -897,14 +852,6 @@ struct LongrangecorrDerived { processSame(col, tracks, ft0cs); } - void processUpcV0mftSE(UpcCollsTable::iterator const& col, V0TrksUpcTable const& tracks, MftTrksUpcTable const& mfts) - { - if (!isUpcEventSelected(col)) { - return; - } - processSame(col, tracks, mfts); - } - void processUpcTpcft0aME(UpcCollsTable const& cols, TrksUpcTable const& tracks, Ft0aTrksUpcTable const& ft0as) { processMixed(cols, tracks, ft0as); @@ -915,16 +862,6 @@ struct LongrangecorrDerived { processMixed(cols, tracks, ft0cs); } - void processUpcTpcmftME(UpcCollsTable const& cols, TrksUpcTable const& tracks, MftTrksUpcTable const& mfts) - { - processMixed(cols, tracks, mfts); - } - - void processUpcMftft0aME(UpcCollsTable const& cols, MftTrksUpcTable const& mfts, Ft0aTrksUpcTable const& ft0as) - { - processMixed(cols, mfts, ft0as); - } - void processUpcV0ft0aME(UpcCollsTable const& cols, V0TrksUpcTable const& tracks, Ft0aTrksUpcTable const& ft0as) { processMixed(cols, tracks, ft0as); @@ -935,11 +872,6 @@ struct LongrangecorrDerived { processMixed(cols, tracks, ft0cs); } - void processUpcV0mftME(UpcCollsTable const& cols, V0TrksUpcTable const& tracks, MftTrksUpcTable const& mfts) - { - processMixed(cols, tracks, mfts); - } - void processMcTpcft0aSE(McCollsTable::iterator const& mccollision, soa::SmallGroups const& collisions, McTrksTable const& tracks, McFt0aTrksTable const& ft0as) { processMcSame(mccollision, collisions, tracks, ft0as); @@ -950,16 +882,6 @@ struct LongrangecorrDerived { processMcSame(mccollision, collisions, tracks, ft0cs); } - void processMcTpcmftSE(McCollsTable::iterator const& mccollision, soa::SmallGroups const& collisions, McTrksTable const& tracks, McMftTrksTable const& mfts) - { - processMcSame(mccollision, collisions, tracks, mfts); - } - - void processMcMftft0aSE(McCollsTable::iterator const& mccollision, soa::SmallGroups const& collisions, McMftTrksTable const& mfts, McFt0aTrksTable const& ft0as) - { - processMcSame(mccollision, collisions, mfts, ft0as); - } - void processMcFt0aft0cSE(McCollsTable::iterator const& mccollision, soa::SmallGroups const& collisions, McFt0aTrksTable const& ft0as, McFt0cTrksTable const& ft0cs) { processMcSame(mccollision, collisions, ft0as, ft0cs); @@ -975,16 +897,6 @@ struct LongrangecorrDerived { processMcMixed(mccollisions, collisions, tracks, ft0cs); } - void processMcTpcmftME(McCollsTable const& mccollisions, aod::LRCollisionsWithLabel const& collisions, McTrksTable const& tracks, McMftTrksTable const& mfts) - { - processMcMixed(mccollisions, collisions, tracks, mfts); - } - - void processMcMftft0aME(McCollsTable const& mccollisions, aod::LRCollisionsWithLabel const& collisions, McMftTrksTable const& mfts, McFt0aTrksTable const& ft0as) - { - processMcMixed(mccollisions, collisions, mfts, ft0as); - } - void processMcFt0aft0cME(McCollsTable const& mccollisions, aod::LRCollisionsWithLabel const& collisions, McFt0aTrksTable const& ft0as, McFt0cTrksTable const& ft0cs) { processMcMixed(mccollisions, collisions, ft0as, ft0cs); @@ -1000,16 +912,6 @@ struct LongrangecorrDerived { processMcGenSame(mccollision, tracks, ft0cs); } - void processMcGenTpcmftSE(McCollsTable::iterator const& mccollision, McTrksTable const& tracks, McMftTrksTable const& mfts) - { - processMcGenSame(mccollision, tracks, mfts); - } - - void processMcGenMftft0aSE(McCollsTable::iterator const& mccollision, McMftTrksTable const& mfts, McFt0aTrksTable const& ft0as) - { - processMcGenSame(mccollision, mfts, ft0as); - } - void processMcGenV0ft0aSE(McCollsTable::iterator const& mccollision, McTrksTable const& tracks, McFt0aTrksTable const& ft0as) { processMcGenSame(mccollision, tracks, ft0as); @@ -1035,16 +937,6 @@ struct LongrangecorrDerived { processMcGenMixed(mccollisions, tracks, ft0cs); } - void processMcGenTpcmftME(McCollsTable const& mccollisions, McTrksTable const& tracks, McMftTrksTable const& mfts) - { - processMcGenMixed(mccollisions, tracks, mfts); - } - - void processMcGenMftft0aME(McCollsTable const& mccollisions, McMftTrksTable const& mfts, McFt0aTrksTable const& ft0as) - { - processMcGenMixed(mccollisions, mfts, ft0as); - } - void processMcGenV0ft0aME(McCollsTable const& mccollisions, McTrksTable const& tracks, McFt0aTrksTable const& ft0as) { processMcGenMixed(mccollisions, tracks, ft0as); @@ -1152,17 +1044,34 @@ struct LongrangecorrDerived { if (cfgSel.cfgGetdEdx) { int pdgIdx = 0; + float tofNsigMC = -999.0f; + float expSigmaMC = 0.0f; auto absPdg = std::abs(particle.pdgCode()); - if (absPdg == PDG_t::kPiPlus) + if (absPdg == PDG_t::kPiPlus) { pdgIdx = 1; // o2-linter: disable=pdg/explicit-code (histogram species index) - else if (absPdg == PDG_t::kKPlus) + tofNsigMC = track.tofNSigmaPi(); + expSigmaMC = track.tpcExpSigmaPi(); + } else if (absPdg == PDG_t::kKPlus) { pdgIdx = 2; // o2-linter: disable=pdg/explicit-code (histogram species index) - else if (absPdg == PDG_t::kProton) + tofNsigMC = track.tofNSigmaKa(); + expSigmaMC = track.tpcExpSigmaKa(); + } else if (absPdg == PDG_t::kProton) { pdgIdx = 3; // o2-linter: disable=pdg/explicit-code (histogram species index) + tofNsigMC = track.tofNSigmaPr(); + expSigmaMC = track.tpcExpSigmaPr(); + } if (pdgIdx > 0) { - histos.fill(HIST("MC_TpcdEdx_ptwise"), static_cast(pdgIdx), track.pt(), track.tpcSignal()); + if (track.hasTOF()) { + histos.fill(HIST("MC_TpcdEdx_TofNsigma_ptwise"), static_cast(pdgIdx), track.pt(), track.tpcSignal(), tofNsigMC); + histos.fill(HIST("MC_ExpSigma_ptwise"), static_cast(pdgIdx), track.pt(), expSigmaMC, tofNsigMC); + } + bool passTofForMC = !cfgSel.cfgRequireTofInMCdEdx || + (track.hasTOF() && tofNsigMC > cfgSel.cfgCleanNsigmaTofMin && tofNsigMC < cfgSel.cfgCleanNsigmaTofMax); + if (passTofForMC) { + histos.fill(HIST("MC_TpcdEdx_ptwise"), static_cast(pdgIdx), track.pt(), track.tpcSignal()); + } } } @@ -1209,82 +1118,256 @@ struct LongrangecorrDerived { using CollStandardTable = soa::Join; using TrksStandardTable = soa::Join; - void processPIDQA(CollsTable const& lrCollisions, TrksStandardTable const& standardTracks) + template + float countFallbackMultiplicity(TTracks const& tracks, float vz) { - for (auto const& col : lrCollisions) { - - if (std::abs(col.posZ()) >= cfgSel.cfgVtxCut) { + float nTrk = 0.0f; + for (auto const& trk : tracks) { + if (!trk.isGlobalTrack()) + continue; + if (!myTrackFilter.IsSelected(trk)) continue; + if (trk.pt() < cfgSel.cfgPtCutMinForMult || trk.pt() > cfgSel.cfgPtCutMaxForMult) + continue; + nTrk += getTrkEffCorr(vz, trk.eta(), trk.pt()); + } + return nTrk; + } + + template + void fillCleanV0Daughters(TCollision const& rawCol, TV0 const& v0, TTrack const& posTrack, TTrack const& negTrack, float multiplicity) + { + if (!posTrack.hasTPC() || !negTrack.hasTPC()) + return; + if (posTrack.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows || negTrack.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows) + return; + if (std::abs(v0.positiveeta()) > cfgSel.cfgEtaCut || std::abs(v0.negativeeta()) > cfgSel.cfgEtaCut) + return; + if (v0.v0cosPA() < cfgSel.cfgCleanV0MinCosPA) + return; + if (v0.dcaV0daughters() > cfgSel.cfgCleanV0MaxDcaDau) + return; + if (v0.v0radius() < cfgSel.cfgCleanV0MinRadius || v0.v0radius() > cfgSel.cfgCleanV0MaxRadius) + return; + + float distOverP = v0.distovertotmom(rawCol.posX(), rawCol.posY(), rawCol.posZ()); + + auto fillV0Probe = [&](double v0CleanType, TTrack const& probeTrack, float tpcNsig, float tofNsigReal, float expSigma, bool isPionProbe, bool isProtonProbe) { + if (!probeTrack.isGlobalTrack() || !myTrackFilter.IsSelected(probeTrack)) + return; + + const float tofVal = probeTrack.hasTOF() ? tofNsigReal : -999.0f; + + if (cfgSel.cfgGetV0CleanSample && cfgSel.cfgGetdEdx) { + histos.fill(HIST("V0_TpcdEdx_ptwise"), v0CleanType, multiplicity, probeTrack.pt(), probeTrack.tpcSignal(), tofVal); + histos.fill(HIST("V0_ExpSigma_ptwise"), v0CleanType, multiplicity, probeTrack.pt(), expSigma, tofVal); } - // EXTRACT CENTRALITY/MULTIPLICITY - float multiplicity = 1.0f; - if constexpr (requires { col.centrality(); }) { - if (cfgSel.isUseCentEst) - multiplicity = col.centrality(); - else - multiplicity = col.multiplicity(); + if (cfgSel.cfgFillAfterCutWithV0 && cfgSel.cfgGetNsigmaQA) { + const bool passTofForAfterCut = !cfgSel.cfgRequireTofForV0AfterCut || + (probeTrack.hasTOF() && tofNsigReal > cfgSel.cfgCleanNsigmaTofMin && tofNsigReal < cfgSel.cfgCleanNsigmaTofMax); + const bool matchWagon = ((cfgSel.cfgPidMask & KPidMaskPion) && isPionProbe) || + ((cfgSel.cfgPidMask & KPidMaskProton) && isProtonProbe); + if (matchWagon && passTofForAfterCut) { + histos.fill(HIST("TofTpcNsigma_after"), multiplicity, probeTrack.pt(), tpcNsig, tofVal); + if (cfgSel.cfgGetdEdx) { + histos.fill(HIST("TpcdEdx_ptwise_afterCut"), multiplicity, probeTrack.pt(), probeTrack.tpcSignal(), tofVal); + } + } + } + }; + + float ctauK0s = distOverP * o2::constants::physics::MassK0; + bool isK0sTopo = (std::abs(v0.mK0Short() - o2::constants::physics::MassK0) < cfgSel.cfgCleanK0sMassWin) && + (v0.qtarm() >= cfgSel.cfgCleanK0sMinArmQt * std::abs(v0.alpha())) && + (std::abs(ctauK0s) <= cfgSel.cfgCleanK0sMaxCtau) && + (std::abs(v0.dcapostopv()) >= cfgSel.cfgCleanK0sMinDcaToPv) && + (std::abs(v0.dcanegtopv()) >= cfgSel.cfgCleanK0sMinDcaToPv); + + if (isK0sTopo) { + if (cfgSel.cfgGetV0CleanSample && cfgSel.cfgGetdEdx) { + histos.fill(HIST("hCleanK0s_MassVsPt"), v0.pt(), v0.mK0Short()); + } + if (std::abs(negTrack.tpcNSigmaPi()) < cfgSel.cfgCleanV0TagTpcNsigma) { + fillV0Probe(1.0, posTrack, posTrack.tpcNSigmaPi(), posTrack.tofNSigmaPi(), posTrack.tpcExpSigmaPi(), true, false); + } + if (std::abs(posTrack.tpcNSigmaPi()) < cfgSel.cfgCleanV0TagTpcNsigma) { + fillV0Probe(1.0, negTrack, negTrack.tpcNSigmaPi(), negTrack.tofNSigmaPi(), negTrack.tpcExpSigmaPi(), true, false); + } + } + + float ctauLambda = distOverP * o2::constants::physics::MassLambda; + bool passK0sRej = std::abs(v0.mK0Short() - o2::constants::physics::MassK0) >= cfgSel.cfgCleanLambdaRejK0sWin; + bool passLambdaArm = v0.qtarm() >= cfgSel.cfgCleanLambdaMinArmQt; + bool passLambdaCtau = std::abs(ctauLambda) <= cfgSel.cfgCleanLambdaMaxCtau; + + if (passK0sRej && passLambdaArm && passLambdaCtau) { + bool isLambdaTopo = (std::abs(v0.mLambda() - o2::constants::physics::MassLambda) < cfgSel.cfgCleanLambdaMassWin) && + (std::abs(v0.dcapostopv()) >= cfgSel.cfgCleanLambdaMinDcaPr) && + (std::abs(v0.dcanegtopv()) >= cfgSel.cfgCleanLambdaMinDcaPi); + if (isLambdaTopo) { + if (cfgSel.cfgGetV0CleanSample && cfgSel.cfgGetdEdx) { + histos.fill(HIST("hCleanLambda_MassVsPt"), v0.pt(), v0.mLambda()); + } + if (std::abs(negTrack.tpcNSigmaPi()) < cfgSel.cfgCleanV0TagTpcNsigma) { + fillV0Probe(2.0, posTrack, posTrack.tpcNSigmaPr(), posTrack.tofNSigmaPr(), posTrack.tpcExpSigmaPr(), false, true); + } + if (std::abs(posTrack.tpcNSigmaPr()) < cfgSel.cfgCleanV0TagTpcNsigma) { + fillV0Probe(3.0, negTrack, negTrack.tpcNSigmaPi(), negTrack.tofNSigmaPi(), negTrack.tpcExpSigmaPi(), cfgSel.cfgIncludeLambdaPiInCleanPi, false); + } + } + + bool isAntiLambdaTopo = (std::abs(v0.mAntiLambda() - o2::constants::physics::MassLambda) < cfgSel.cfgCleanLambdaMassWin) && + (std::abs(v0.dcapostopv()) >= cfgSel.cfgCleanLambdaMinDcaPi) && + (std::abs(v0.dcanegtopv()) >= cfgSel.cfgCleanLambdaMinDcaPr); + if (isAntiLambdaTopo) { + if (cfgSel.cfgGetV0CleanSample && cfgSel.cfgGetdEdx) { + histos.fill(HIST("hCleanLambda_MassVsPt"), v0.pt(), v0.mAntiLambda()); + } + if (std::abs(posTrack.tpcNSigmaPi()) < cfgSel.cfgCleanV0TagTpcNsigma) { + fillV0Probe(2.0, negTrack, negTrack.tpcNSigmaPr(), negTrack.tofNSigmaPr(), negTrack.tpcExpSigmaPr(), false, true); + } + if (std::abs(negTrack.tpcNSigmaPr()) < cfgSel.cfgCleanV0TagTpcNsigma) { + fillV0Probe(3.0, posTrack, posTrack.tpcNSigmaPi(), posTrack.tofNSigmaPi(), posTrack.tpcExpSigmaPi(), cfgSel.cfgIncludeLambdaPiInCleanPi, false); + } + } + } + } + + void processPIDQA(CollStandardTable const& rawCollisions, CollsTable const& lrCollisions, + TrksStandardTable const& standardTracks, aod::V0Datas const& V0s) + { + int64_t lrIdx = 0; + const int64_t nLrCols = lrCollisions.size(); + + for (auto const& rawCol : rawCollisions) { + histos.fill(HIST("hPIDQA_EventCount"), 1.0); + + bool matched = false; + float multiplicity = -1.0f; + if (nLrCols > 0 && lrIdx < nLrCols) { + if (std::abs(lrCollisions.iteratorAt(lrIdx).posZ() - rawCol.posZ()) <= 1e-5f) { + auto const& lrCol = lrCollisions.iteratorAt(lrIdx); + multiplicity = cfgSel.isUseCentEst ? lrCol.centrality() : lrCol.multiplicity(); + lrIdx++; + matched = true; + } + } + + if (!isEventSelected(rawCol)) { + continue; + } + histos.fill(HIST("hPIDQA_EventCount"), 2.0); + + if (matched) { + histos.fill(HIST("hPIDQA_EventCount"), 3.0); + } else if (nLrCols == 0 && cfgSel.cfgAllowFallbackMultInPIDQA) { + auto tracksForMult = standardTracks.sliceByCached(aod::track::collisionId, rawCol.globalIndex(), this->cache); + multiplicity = countFallbackMultiplicity(tracksForMult, rawCol.posZ()); + histos.fill(HIST("hPIDQA_EventCount"), 3.0); } else { - multiplicity = col.multiplicity(); + histos.fill(HIST("hPIDQA_EventCount"), 4.0); + continue; } - auto tracks = standardTracks.sliceByCached(aod::track::collisionId, col.globalIndex(), this->cache); + auto tracks = standardTracks.sliceByCached(aod::track::collisionId, rawCol.globalIndex(), this->cache); for (auto const& track : tracks) { if (!track.isGlobalTrack()) continue; if (!myTrackFilter.IsSelected(track)) continue; - if (!track.hasTOF()) continue; - float tpcNsig = 0.0f, tofNsig = 0.0f; - if (cfgSel.cfgPidMask & KPidMaskPion) { - tpcNsig = track.tpcNSigmaPi(); - tofNsig = track.tofNSigmaPi(); - } else if (cfgSel.cfgPidMask & KPidMaskKaon) { - tpcNsig = track.tpcNSigmaKa(); - tofNsig = track.tofNSigmaKa(); - } else if (cfgSel.cfgPidMask & KPidMaskProton) { - tpcNsig = track.tpcNSigmaPr(); - tofNsig = track.tofNSigmaPr(); + const float tpcNsigPi = track.tpcNSigmaPi(), tofNsigPi = track.tofNSigmaPi(), expSigPi = track.tpcExpSigmaPi(); + const float tpcNsigKa = track.tpcNSigmaKa(), tofNsigKa = track.tofNSigmaKa(), expSigKa = track.tpcExpSigmaKa(); + const float tpcNsigPr = track.tpcNSigmaPr(), tofNsigPr = track.tofNSigmaPr(), expSigPr = track.tpcExpSigmaPr(); + + const bool isTpcCleanPi = (tpcNsigPi > cfgSel.cfgCleanNsigmaTpcMin && tpcNsigPi < cfgSel.cfgCleanNsigmaTpcMax); + const bool isTpcCleanKa = (tpcNsigKa > cfgSel.cfgCleanNsigmaTpcMin && tpcNsigKa < cfgSel.cfgCleanNsigmaTpcMax); + const bool isTpcCleanPr = (tpcNsigPr > cfgSel.cfgCleanNsigmaTpcMin && tpcNsigPr < cfgSel.cfgCleanNsigmaTpcMax); + + const bool isTofCleanPi = (tofNsigPi > cfgSel.cfgCleanNsigmaTofMin && tofNsigPi < cfgSel.cfgCleanNsigmaTofMax) && + (std::abs(tofNsigKa) > cfgSel.cfgCleanTofVetoNsigma) && + (std::abs(tofNsigPr) > cfgSel.cfgCleanTofVetoNsigma); + const bool isTofCleanKa = (tofNsigKa > cfgSel.cfgCleanNsigmaTofMin && tofNsigKa < cfgSel.cfgCleanNsigmaTofMax) && + (std::abs(tofNsigPi) > cfgSel.cfgCleanTofVetoNsigma) && + (std::abs(tofNsigPr) > cfgSel.cfgCleanTofVetoNsigma); + const bool isTofCleanPr = (tofNsigPr > cfgSel.cfgCleanNsigmaTofMin && tofNsigPr < cfgSel.cfgCleanNsigmaTofMax) && + (std::abs(tofNsigPi) > cfgSel.cfgCleanTofVetoNsigma) && + (std::abs(tofNsigKa) > cfgSel.cfgCleanTofVetoNsigma); + + const bool isCleanPi = isTofCleanPi && isTpcCleanPi; + const bool isCleanKa = isTofCleanKa && isTpcCleanKa; + const bool isCleanPr = isTofCleanPr && isTpcCleanPr; + + if (cfgSel.cfgGetAllSpeciesQA && cfgSel.cfgGetdEdx) { + histos.fill(HIST("TpcdEdx_allSpecies_ptwise"), 1.0, multiplicity, track.pt(), track.tpcSignal(), tofNsigPi); + histos.fill(HIST("TpcdEdx_allSpecies_ptwise"), 2.0, multiplicity, track.pt(), track.tpcSignal(), tofNsigKa); + histos.fill(HIST("TpcdEdx_allSpecies_ptwise"), 3.0, multiplicity, track.pt(), track.tpcSignal(), tofNsigPr); + + histos.fill(HIST("ExpSigma_allSpecies_ptwise"), 1.0, multiplicity, track.pt(), expSigPi, tofNsigPi); + histos.fill(HIST("ExpSigma_allSpecies_ptwise"), 2.0, multiplicity, track.pt(), expSigKa, tofNsigKa); + histos.fill(HIST("ExpSigma_allSpecies_ptwise"), 3.0, multiplicity, track.pt(), expSigPr, tofNsigPr); + + if (isCleanPi) { + histos.fill(HIST("TpcdEdx_allSpecies_afterCut"), 1.0, multiplicity, track.pt(), track.tpcSignal(), tofNsigPi); + } + if (isCleanKa) { + histos.fill(HIST("TpcdEdx_allSpecies_afterCut"), 2.0, multiplicity, track.pt(), track.tpcSignal(), tofNsigKa); + } + if (isCleanPr) { + histos.fill(HIST("TpcdEdx_allSpecies_afterCut"), 3.0, multiplicity, track.pt(), track.tpcSignal(), tofNsigPr); + } } - // FILL BEFORE CUTS if (cfgSel.cfgGetNsigmaQA && (cfgSel.cfgPidMask == KPidMaskPion || cfgSel.cfgPidMask == KPidMaskKaon || cfgSel.cfgPidMask == KPidMaskProton)) { + float tpcNsig = 0.0f, tofNsig = 0.0f, expSig = 0.0f; + bool isTargetClean = false; + + if (cfgSel.cfgPidMask & KPidMaskPion) { + tpcNsig = tpcNsigPi; + tofNsig = tofNsigPi; + expSig = expSigPi; + isTargetClean = isCleanPi; + } else if (cfgSel.cfgPidMask & KPidMaskKaon) { + tpcNsig = tpcNsigKa; + tofNsig = tofNsigKa; + expSig = expSigKa; + isTargetClean = isCleanKa; + } else if (cfgSel.cfgPidMask & KPidMaskProton) { + tpcNsig = tpcNsigPr; + tofNsig = tofNsigPr; + expSig = expSigPr; + isTargetClean = isCleanPr; + } + + const float expSignal = track.tpcSignal() - (tpcNsig * expSig); + histos.fill(HIST("TofTpcNsigma_before"), multiplicity, track.pt(), tpcNsig, tofNsig); if (cfgSel.cfgGetdEdx) { histos.fill(HIST("TpcdEdx_ptwise"), multiplicity, track.pt(), track.tpcSignal(), tofNsig); + histos.fill(HIST("ExpTpcdEdx_ptwise"), multiplicity, track.pt(), expSignal, tofNsig); + histos.fill(HIST("ExpSigma_ptwise"), multiplicity, track.pt(), expSig, tofNsig); } - } - - bool isTpcPion = (track.tpcNSigmaPi() > cfgSel.cfgCleanNsigmaTpcMin && track.tpcNSigmaPi() < cfgSel.cfgCleanNsigmaTpcMax); - bool isTpcKaon = (track.tpcNSigmaKa() > cfgSel.cfgCleanNsigmaTpcMin && track.tpcNSigmaKa() < cfgSel.cfgCleanNsigmaTpcMax); - bool isTpcProton = (track.tpcNSigmaPr() > cfgSel.cfgCleanNsigmaTpcMin && track.tpcNSigmaPr() < cfgSel.cfgCleanNsigmaTpcMax); - - bool isTofPion = (track.tofNSigmaPi() > cfgSel.cfgCleanNsigmaTofMin && track.tofNSigmaPi() < cfgSel.cfgCleanNsigmaTofMax); - bool isTofKaon = (track.tofNSigmaKa() > cfgSel.cfgCleanNsigmaTofMin && track.tofNSigmaKa() < cfgSel.cfgCleanNsigmaTofMax); - bool isTofProton = (track.tofNSigmaPr() > cfgSel.cfgCleanNsigmaTofMin && track.tofNSigmaPr() < cfgSel.cfgCleanNsigmaTofMax); - bool isPion = isTofPion && isTpcPion; - bool isKaon = isTofKaon && isTpcKaon; - bool isProton = isTofProton && isTpcProton; - - if ((isPion && isKaon) || (isPion && isProton) || (isKaon && isProton)) { - isPion = isKaon = isProton = false; + const bool useTrackCleanHere = !cfgSel.cfgFillAfterCutWithV0 || (cfgSel.cfgPidMask == KPidMaskKaon); + if (useTrackCleanHere && isTargetClean) { + histos.fill(HIST("TofTpcNsigma_after"), multiplicity, track.pt(), tpcNsig, tofNsig); + if (cfgSel.cfgGetdEdx) { + histos.fill(HIST("TpcdEdx_ptwise_afterCut"), multiplicity, track.pt(), track.tpcSignal(), tofNsig); + } + } } + } - bool isTargetParticle = ((cfgSel.cfgPidMask & KPidMaskPion) && isPion) || - ((cfgSel.cfgPidMask & KPidMaskKaon) && isKaon) || - ((cfgSel.cfgPidMask & KPidMaskProton) && isProton); - - // FILL AFTER CUTS - if (cfgSel.cfgGetNsigmaQA && isTargetParticle) { - histos.fill(HIST("TofTpcNsigma_after"), multiplicity, track.pt(), tpcNsig, tofNsig); - if (cfgSel.cfgGetdEdx) { - histos.fill(HIST("TpcdEdx_ptwise_afterCut"), multiplicity, track.pt(), track.tpcSignal(), tofNsig); - } + if ((cfgSel.cfgGetV0CleanSample || cfgSel.cfgFillAfterCutWithV0) && cfgSel.cfgGetdEdx) { + auto v0sThisCol = V0s.sliceByCached(aod::v0data::collisionId, rawCol.globalIndex(), this->cache); + for (auto const& v0 : v0sThisCol) { + auto const& posTrack = v0.template posTrack_as(); + auto const& negTrack = v0.template negTrack_as(); + fillCleanV0Daughters(rawCol, v0, posTrack, negTrack, multiplicity); } } } @@ -1294,52 +1377,32 @@ struct LongrangecorrDerived { PROCESS_SWITCH(LongrangecorrDerived, processTpcft0aME, "mixed event TPC vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processTpcft0cSE, "same event TPC vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processTpcft0cME, "mixed event TPC vs FT0C", false); - PROCESS_SWITCH(LongrangecorrDerived, processTpcmftSE, "same event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processTpcmftME, "mixed event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processMftft0aSE, "same event MFT vs FT0A", false); - PROCESS_SWITCH(LongrangecorrDerived, processMftft0aME, "mixed event MFT vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processV0ft0aSE, "same event V0 vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processV0ft0aME, "mixed event V0 vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processV0ft0cSE, "same event V0 vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processV0ft0cME, "mixed event V0 vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processV0tpcSE, "same event V0 vs TPC", false); PROCESS_SWITCH(LongrangecorrDerived, processV0tpcME, "mixed event V0 vs TPC", false); - PROCESS_SWITCH(LongrangecorrDerived, processV0mftSE, "same event V0 vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processV0mftME, "mixed event V0 vs MFT", false); PROCESS_SWITCH(LongrangecorrDerived, processFt0aft0cSE, "same event FT0A vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processFt0aft0cME, "mixed event FT0A vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0aSE, "same UPC event TPC vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0aME, "mixed UPC event TPC vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0cSE, "same UPC event TPC vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcft0cME, "mixed UPC event TPC vs FT0C", false); - PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcmftSE, "same UPC event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processUpcTpcmftME, "mixed UPC event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processUpcMftft0aSE, "same UPC event MFT vs FT0A", false); - PROCESS_SWITCH(LongrangecorrDerived, processUpcMftft0aME, "mixed UPC event MFT vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcV0ft0aSE, "same UPC event V0 vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcV0ft0aME, "mixed UPC event V0 vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcV0ft0cSE, "same UPC event V0 vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processUpcV0ft0cME, "mixed UPC event V0 vs FT0C", false); - PROCESS_SWITCH(LongrangecorrDerived, processUpcV0mftSE, "same UPC event V0 vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processUpcV0mftME, "mixed UPC event V0 vs MFT", false); PROCESS_SWITCH(LongrangecorrDerived, processMcTpcft0aSE, "same MC event TPC vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcTpcft0aME, "mixed MC event TPC vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcTpcft0cSE, "same MC event TPC vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processMcTpcft0cME, "mixed MC event TPC vs FT0C", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcTpcmftSE, "same MC event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcTpcmftME, "mixed MC event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcMftft0aSE, "same MC event MFT vs FT0A", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcMftft0aME, "mixed MC event MFT vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcFt0aft0cSE, "same MC event FT0A vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processMcFt0aft0cME, "mixed MC event FT0A vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processMcGenTpcft0aSE, "same MC gen event TPC vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcGenTpcft0aME, "mixed MC gen event TPC vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcGenTpcft0cSE, "same MC gen event TPC vs FT0C", false); PROCESS_SWITCH(LongrangecorrDerived, processMcGenTpcft0cME, "mixed MC gen event TPC vs FT0C", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcGenTpcmftSE, "same MC gen event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcGenTpcmftME, "mixed MC gen event TPC vs MFT", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcGenMftft0aSE, "same MC gen event MFT vs FT0A", false); - PROCESS_SWITCH(LongrangecorrDerived, processMcGenMftft0aME, "mixed MC gen event MFT vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcGenV0ft0aSE, "same MC gen event V0 vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcGenV0ft0aME, "mixed MC gen event V0 vs FT0A", false); PROCESS_SWITCH(LongrangecorrDerived, processMcGenV0ft0cSE, "same MC gen event V0 vs FT0C", false); From 34bd3bbd54db496f376f9bc4f553130cea672121 Mon Sep 17 00:00:00 2001 From: Soumyadip Ghosh Date: Sat, 7 Nov 2026 23:52:10 +0530 Subject: [PATCH 2/5] Remove MFT track selection logic Removed MFT track selection configurations and related processing code. --- .../TableProducer/longrangeMaker.cxx | 204 +----------------- 1 file changed, 11 insertions(+), 193 deletions(-) diff --git a/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx b/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx index d9d528c64b0..2c92ae20425 100644 --- a/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx +++ b/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx @@ -18,7 +18,6 @@ #include "PWGCF/Core/CorrelationContainer.h" #include "PWGCF/TwoParticleCorrelations/DataModel/LongRangeDerived.h" #include "PWGLF/DataModel/LFStrangenessTables.h" -#include "PWGMM/Mult/DataModel/bestCollisionTable.h" #include "PWGUD/Core/SGCutParHolder.h" #include "PWGUD/Core/SGSelector.h" #include "PWGUD/Core/UDHelpers.h" @@ -62,6 +61,7 @@ #include #include +#include #include #include #include @@ -152,20 +152,6 @@ struct LongrangeMaker { Configurable cfgEffccdbPath{"cfgEffccdbPath", "Users/a/abmodak/Efficiency/OO/default", "Browse track eff object from CCDB"}; } cfgtrksel; - struct : ConfigurableGroup { - std::string prefix = "MftTrackSelection_group"; - Configurable cfgUseChi2Cut{"cfgUseChi2Cut", false, "Use condition on MFT track: chi2/Nclusters"}; - Configurable useMftPtCut{"useMftPtCut", true, "Choose to apply MFT track pT cut"}; - Configurable cfgMftCluster{"cfgMftCluster", 5, "cut on MFT Cluster"}; - Configurable cfgMftEtaMax{"cfgMftEtaMax", -2.4f, "Maximum MFT eta cut"}; - Configurable cfgMftEtaMin{"cfgMftEtaMin", -3.6f, "Minimum MFT eta cut"}; - Configurable cfgMftDcaxy{"cfgMftDcaxy", 2.0f, "cut on DCA xy for MFT tracks"}; - Configurable cfgMftDcaz{"cfgMftDcaz", 2.0f, "cut on DCA z for MFT tracks"}; - Configurable cfgMftPtCutMin{"cfgMftPtCutMin", 0.f, "minimum accepted MFT track pT"}; - Configurable cfgMftPtCutMax{"cfgMftPtCutMax", 10.f, "maximum accepted MFT track pT"}; - Configurable cfgMaxChi2NCl{"cfgMaxChi2NCl", 1.f, "Cut on MFT track: chi2/Nclusters"}; - } cfgmfttrksel; - struct : ConfigurableGroup { std::string prefix = "FitTrackSelection_group"; Configurable cfgFt0aEtaMax{"cfgFt0aEtaMax", 4.9f, "Maximum FT0A eta cut"}; @@ -214,7 +200,6 @@ struct LongrangeMaker { std::string prefix = "ConfigAxis_group"; ConfigurableAxis axisAmplitude{"axisAmplitude", {5000, 0, 10000}, "FT0 amplitude"}; ConfigurableAxis axisChannel{"axisChannel", {208, 0, 208}, "FT0 channel"}; - ConfigurableAxis axisMFTAmbDegree{"axisMFTAmbDegree", {50, -0.5, 49.5}, "Track Ambiguity axis"}; ConfigurableAxis axisEta = {"axisEta", {100, -5, 5}, "eta axis"}; ConfigurableAxis axisPhi{"axisPhi", {72, 0, TwoPI}, "#phi axis"}; @@ -302,25 +287,6 @@ struct LongrangeMaker { histos.add("hSelectionResult", "hSelectionResult", kTH1I, {{5, -0.5, 4.5}}); - histos.add("hMftTrkSel", "hMftTrkSel", kTH1D, {axisTrackSel}, false); - auto hMftTrkStat = histos.get(HIST("hMftTrkSel")); - auto* xMftTrk = hMftTrkStat->GetXaxis(); - xMftTrk->SetBinLabel(1, "All"); - xMftTrk->SetBinLabel(2, "Cluster selection"); - xMftTrk->SetBinLabel(3, "Chi2/NCluster selection"); - xMftTrk->SetBinLabel(4, "eta selection"); - xMftTrk->SetBinLabel(5, "pT selection"); - xMftTrk->SetBinLabel(6, "CA track selection"); - - histos.add("hMftBestTrkSel", "hMftBestTrkSel", kTH1D, {axisTrackSel}, false); - auto hMftBestTrkStat = histos.get(HIST("hMftBestTrkSel")); - auto* xMftBestTrk = hMftBestTrkStat->GetXaxis(); - xMftBestTrk->SetBinLabel(1, "All"); - xMftBestTrk->SetBinLabel(2, "BestSelCollID selection"); - xMftBestTrk->SetBinLabel(3, "Orphan track selection"); - xMftBestTrk->SetBinLabel(4, "DCAxy selection"); - xMftBestTrk->SetBinLabel(5, "DCAz selection"); - histos.add("FT0A_Amp", "FT0A_Amp", kTH1D, {cfgAxis.axisAmplitude}); histos.add("FT0A_Amp_gaincorrected", "FT0A_Amp_gaincorrected", kTH1D, {cfgAxis.axisAmplitude}); histos.add("FT0A_Channel_vs_Amp", "FT0A_Channel_vs_Amp", kTH2D, {cfgAxis.axisChannel, cfgAxis.axisAmplitude}); @@ -374,14 +340,12 @@ struct LongrangeMaker { Produces lrmidmctracks; Produces lrft0amctracks; Produces lrft0cmctracks; - Produces lrmftmctracks; Produces lrcollision; Produces lrcollisionMcLabel; Produces lrmidtracks; Produces lrft0atracks; Produces lrft0ctracks; - Produces lrmfttracks; Produces lrv0tracks; Produces upclrcollision; @@ -391,7 +355,6 @@ struct LongrangeMaker { Produces upclrmidtracks; Produces upclrft0atracks; Produces upclrft0ctracks; - Produces upclrmfttracks; Produces upclrv0tracks; Filter fTracksEta = nabs(aod::track::eta) < cfgtrksel.cfgEtaCut; @@ -399,13 +362,12 @@ struct LongrangeMaker { using CollTable = soa::Join; using TrksTable = soa::Filtered>; - using MftTrkTable = aod::MFTTracks; using BCs = soa::Join; std::vector ft0gainvalues{}; - void processData(CollTable::iterator const& col, TrksTable const& tracks, - aod::FT0s const&, MftTrkTable const&, - soa::SmallGroups const& reassoMftTracks, + void processData(CollTable::iterator const& col, + TrksTable const& tracks, + aod::FT0s const&, aod::V0Datas const& V0s, aod::BCsWithTimestamps const&) { if (!isEventSelected(col)) { @@ -548,28 +510,6 @@ struct LongrangeMaker { } } - // mft tracks - for (const auto& reassoMftTrack : reassoMftTracks) { - if (!isMftBestTrackSelected(reassoMftTrack)) - continue; - auto itrack = reassoMftTrack.template mfttrack_as(); - if (!isMftTrackSelected(itrack)) { - continue; - } - auto phi = itrack.phi(); - o2::math_utils::bringTo02Pi(phi); - lrmfttracks(lrcollision.lastIndex(), - reassoMftTrack.ambDegree(), - itrack.pt(), - itrack.eta(), - phi, - itrack.nClusters(), - reassoMftTrack.bestDCAXY(), - reassoMftTrack.bestDCAZ(), - itrack.isCA(), - itrack.collisionId() != reassoMftTrack.bestCollisionId()); - } - // v0 loop for (const auto& v0 : V0s) { if (!isSelectV0Track(v0)) { // Quality selection for V0 prongs @@ -624,9 +564,7 @@ struct LongrangeMaker { void processUpc(CollTable::iterator const& col, BCs const& bcs, TrksTable const& tracks, aod::Zdcs const&, aod::FV0As const& fv0as, aod::FT0s const& ft0s, - aod::FDDs const& fdds, MftTrkTable const&, - soa::SmallGroups const& reassoMftTracks, - aod::V0Datas const& V0s) + aod::FDDs const& fdds, aod::V0Datas const& V0s) { if (!isEventSelected(col)) { return; @@ -728,27 +666,6 @@ struct LongrangeMaker { } } - for (const auto& reassoMftTrack : reassoMftTracks) { - if (!isMftBestTrackSelected(reassoMftTrack)) - continue; - auto itrack = reassoMftTrack.template mfttrack_as(); - if (!isMftTrackSelected(itrack)) { - continue; - } - auto phi = itrack.phi(); - o2::math_utils::bringTo02Pi(phi); - upclrmfttracks(upclrcollision.lastIndex(), - reassoMftTrack.ambDegree(), - itrack.pt(), - itrack.eta(), - phi, - itrack.nClusters(), - reassoMftTrack.bestDCAXY(), - reassoMftTrack.bestDCAZ(), - itrack.isCA(), - itrack.collisionId() != reassoMftTrack.bestCollisionId()); - } - // v0 loop for (const auto& v0 : V0s) { if (!isSelectV0Track(v0)) { // Quality selection for V0 prongs @@ -804,13 +721,14 @@ struct LongrangeMaker { using ColMCTrueTable = soa::Join; using ColMCRecTable = soa::SmallGroups>; using TrksMCRecTable = soa::Filtered>; - using MftTrkMCRecTable = soa::Join; Preslice perColMidtrack = aod::track::collisionId; - PresliceUnsorted perColMftTrack = aod::fwdtrack::bestCollisionId; - void processMCRec(ColMCTrueTable::iterator const& mcCollision, ColMCRecTable const& RecCols, TrksMCRecTable const& RecTracks, - aod::FT0s const&, MftTrkMCRecTable const&, aod::BestCollisionsFwd3d const& reassoMftTracks, - aod::McParticles const& mcparticles, aod::BCsWithTimestamps const&) + void processMCRec(ColMCTrueTable::iterator const& mcCollision, + ColMCRecTable const& RecCols, + TrksMCRecTable const& RecTracks, + aod::FT0s const&, + aod::McParticles const& mcparticles, + aod::BCsWithTimestamps const&) { auto multiplicity = 0; for (const auto& particle : mcparticles) { @@ -958,28 +876,6 @@ struct LongrangeMaker { } } - auto recMftTracksPart = reassoMftTracks.sliceBy(perColMftTrack, RecCol.globalIndex()); - for (const auto& reassoMftTrack : recMftTracksPart) { - if (!isMftBestTrackSelected(reassoMftTrack)) - continue; - auto itrack = reassoMftTrack.template mfttrack_as(); - if (!isMftTrackSelected(itrack)) { - continue; - } - auto phi = itrack.phi(); - o2::math_utils::bringTo02Pi(phi); - lrmfttracks(lrcollision.lastIndex(), - reassoMftTrack.ambDegree(), - itrack.pt(), - itrack.eta(), - phi, - itrack.nClusters(), - reassoMftTrack.bestDCAXY(), - reassoMftTrack.bestDCAZ(), - itrack.isCA(), - itrack.collisionId() != reassoMftTrack.bestCollisionId()); - } - for (const auto& particle : mcparticles) { if (!isGenPartSelected(particle)) { continue; @@ -992,9 +888,6 @@ struct LongrangeMaker { lrft0amctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) lrft0cmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); - // Fill MFT tracks - if (cfgmfttrksel.cfgMftEtaMin < particle.eta() && particle.eta() < cfgmfttrksel.cfgMftEtaMax && particle.pt() > cfgmfttrksel.cfgMftPtCutMin && particle.pt() < cfgmfttrksel.cfgMftPtCutMax) - lrmftmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); } } } @@ -1028,9 +921,6 @@ struct LongrangeMaker { lrft0amctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) lrft0cmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); - // Fill MFT tracks - if (cfgmfttrksel.cfgMftEtaMin < particle.eta() && particle.eta() < cfgmfttrksel.cfgMftEtaMax && particle.pt() > cfgmfttrksel.cfgMftPtCutMin && particle.pt() < cfgmfttrksel.cfgMftPtCutMax) - lrmftmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); } } @@ -1319,78 +1209,6 @@ struct LongrangeMaker { return -std::log(std::tan(0.5 * theta)); } - template - bool isMftTrackSelected(CheckMftTrack const& track) - { - if constexpr (fillHis) { - histos.fill(HIST("hMftTrkSel"), 1); - } - if (track.nClusters() < cfgmfttrksel.cfgMftCluster) { - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftTrkSel"), 2); - } - if (cfgmfttrksel.cfgUseChi2Cut) { - float nclMft = std::max(2.0f * track.nClusters() - 5.0f, 1.0f); - float mftChi2NCl = track.chi2() / nclMft; - if (mftChi2NCl > cfgmfttrksel.cfgMaxChi2NCl) - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftTrkSel"), 3); - } - if (track.eta() > cfgmfttrksel.cfgMftEtaMax || track.eta() < cfgmfttrksel.cfgMftEtaMin) { - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftTrkSel"), 4); - } - if (cfgmfttrksel.useMftPtCut && (track.pt() < cfgmfttrksel.cfgMftPtCutMin || track.pt() > cfgmfttrksel.cfgMftPtCutMax)) { - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftTrkSel"), 5); - } - if constexpr (fillHis) { - histos.fill(HIST("hMftTrkSel"), 6); - } - return true; - } - - template - bool isMftBestTrackSelected(CheckMftTrack const& mfttrack) - { - if constexpr (fillHis) { - histos.fill(HIST("hMftBestTrkSel"), 1); - } - if (mfttrack.bestCollisionId() < CintZero) { - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftBestTrkSel"), 2); - } - if (mfttrack.ambDegree() == CintZero) { - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftBestTrkSel"), 3); - } - if (std::abs(mfttrack.bestDCAXY()) >= cfgmfttrksel.cfgMftDcaxy) { - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftBestTrkSel"), 4); - } - if (std::abs(mfttrack.bestDCAZ()) >= cfgmfttrksel.cfgMftDcaz) { - return false; - } - if constexpr (fillHis) { - histos.fill(HIST("hMftBestTrkSel"), 5); - } - return true; - } - template bool isSelectV0Track(const T1& v0) { From f9a11b3be326d9bc054f00ff19d1408b56f39f72 Mon Sep 17 00:00:00 2001 From: Soumyadip Ghosh Date: Sat, 7 Nov 2026 23:52:38 +0530 Subject: [PATCH 3/5] Clean up LongRangeDerived.h by removing unused code Removed unused SOA table declarations and includes to clean up the header file. --- .../DataModel/LongRangeDerived.h | 37 ------------------- 1 file changed, 37 deletions(-) diff --git a/PWGCF/TwoParticleCorrelations/DataModel/LongRangeDerived.h b/PWGCF/TwoParticleCorrelations/DataModel/LongRangeDerived.h index a6c9e2286ce..7435a99ecfb 100644 --- a/PWGCF/TwoParticleCorrelations/DataModel/LongRangeDerived.h +++ b/PWGCF/TwoParticleCorrelations/DataModel/LongRangeDerived.h @@ -18,8 +18,6 @@ #ifndef PWGCF_TWOPARTICLECORRELATIONS_DATAMODEL_LONGRANGEDERIVED_H_ #define PWGCF_TWOPARTICLECORRELATIONS_DATAMODEL_LONGRANGEDERIVED_H_ -#include "PWGMM/Mult/DataModel/bestCollisionTable.h" - #include "Common/DataModel/Multiplicity.h" #include @@ -76,14 +74,6 @@ DECLARE_SOA_TABLE(LRFt0cMcTracks, "AOD", "LRFT0CMCTRACK", lrcorrmctrktable::Phi); using LRFt0cMcTrack = LRFt0cMcTracks::iterator; -DECLARE_SOA_TABLE(LRMftMcTracks, "AOD", "LRMFTMCTRACK", - o2::soa::Index<>, - lrcorrmctrktable::LRMcCollisionId, - lrcorrmctrktable::Pt, - lrcorrmctrktable::Eta, - lrcorrmctrktable::Phi); -using LRMftMcTrack = LRMftMcTracks::iterator; - namespace lrcorrcolltable { DECLARE_SOA_INDEX_COLUMN(LRMcCollision, lrMcCollision); @@ -221,20 +211,6 @@ DECLARE_SOA_TABLE(LRV0Tracks, "AOD", "LRV0TRACK", lrcorrtrktable::V0Type); using LRV0Track = LRV0Tracks::iterator; -DECLARE_SOA_TABLE(LRMftTracks, "AOD", "LRMFTTRACK", - o2::soa::Index<>, - lrcorrtrktable::LRCollisionId, - lrcorrtrktable::AmbDegree, - lrcorrtrktable::Pt, - lrcorrtrktable::Eta, - lrcorrtrktable::Phi, - fwdtrack::NClusters, - fwdtrack::BestDCAXY, - fwdtrack::BestDCAZ, - lrcorrtrktable::IsCA, - lrcorrtrktable::IsReassigned); -using LRMftTrack = LRMftTracks::iterator; - DECLARE_SOA_TABLE(UpcLRMidTracks, "AOD", "UPCLRMIDTRACK", o2::soa::Index<>, lrcorrtrktable::UpcLRCollisionId, @@ -280,19 +256,6 @@ DECLARE_SOA_TABLE(UpcLRV0Tracks, "AOD", "UPCLRV0TRACK", lrcorrtrktable::V0Type); using UpcLRV0Track = UpcLRV0Tracks::iterator; -DECLARE_SOA_TABLE(UpcLRMftTracks, "AOD", "UPCLRMFTTRACK", - o2::soa::Index<>, - lrcorrtrktable::UpcLRCollisionId, - lrcorrtrktable::AmbDegree, - lrcorrtrktable::Pt, - lrcorrtrktable::Eta, - lrcorrtrktable::Phi, - fwdtrack::NClusters, - fwdtrack::BestDCAXY, - fwdtrack::BestDCAZ, - lrcorrtrktable::IsCA, - lrcorrtrktable::IsReassigned); -using UpcLRMftTrack = UpcLRMftTracks::iterator; } // namespace o2::aod #endif // PWGCF_TWOPARTICLECORRELATIONS_DATAMODEL_LONGRANGEDERIVED_H_ From b2aae14810e817c5f0297b67685006e9c3fb88c4 Mon Sep 17 00:00:00 2001 From: Soumyadip Ghosh Date: Mon, 9 Nov 2026 18:56:09 +0530 Subject: [PATCH 4/5] Refactor longrangeMaker.cxx for improved clarity --- .../TableProducer/longrangeMaker.cxx | 138 ++++++++++-------- 1 file changed, 81 insertions(+), 57 deletions(-) diff --git a/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx b/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx index 2c92ae20425..c31496536fd 100644 --- a/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx +++ b/PWGCF/TwoParticleCorrelations/TableProducer/longrangeMaker.cxx @@ -52,16 +52,13 @@ #include #include #include -#include #include #include #include -#include #include -#include #include #include #include @@ -78,7 +75,6 @@ using namespace o2::aod::fwdtrack; using namespace o2::aod::evsel; using namespace o2::constants::math; -auto static constexpr CintZero = 0; auto static constexpr KminFt0cCell = 96; auto static constexpr TotFt0Channels = 208; auto static constexpr MinFt0aDeadChannelOuter = 60; @@ -92,8 +88,7 @@ auto static constexpr MinFt0cMirrorChannelOuter = 144; auto static constexpr MaxFt0cMirrorChannelOuter = 147; auto static constexpr MinFt0cOuterRing = 144; -AxisSpec axisEvent{20, 0.5, 20.5, "#Event", "EventAxis"}; -AxisSpec axisTrackSel{10, 0.5, 10.5, "#Track", "TrackAxis"}; +const AxisSpec axisEvent{20, 0.5, 20.5, "#Event", "EventAxis"}; auto static constexpr KminCharge = 3.0f; enum KindOfV0 { @@ -230,8 +225,8 @@ struct LongrangeMaker { Configurable cfgTofPidPtCut{"cfgTofPidPtCut", 0.3f, "Minimum pt to use TOF N-sigma"}; Configurable isUseItsPid{"isUseItsPid", false, "Use ITS PID for particle identification"}; - Service ccdb; - Service pdg; + Service ccdb{}; + Service pdg{}; o2::ccdb::CcdbApi ccdbApi; o2::ft0::Geometry ft0Det; std::vector* offsetFT0{nullptr}; @@ -246,7 +241,7 @@ struct LongrangeMaker { // Create instance of the selector class which runs the gap selection algorithm SGSelector sgSelector; // Create instance of cut holder class to contain the user defined cuts - SGCutParHolder cfgSgCuts = SGCutParHolder(); + SGCutParHolder cfgSgCuts; Configurable sgCuts{"sgCuts", {}, "SG event cuts"}; Configurable cfgGapSide{"cfgGapSide", 2, "cut on UPC events"}; @@ -320,9 +315,9 @@ struct LongrangeMaker { TrackSelection::GlobalTrackRun3DCAxyCut::Default); myTrackFilter.SetPtRange(cfgtrksel.cfgPtCutMin, cfgtrksel.cfgPtCutMax); myTrackFilter.SetEtaRange(-cfgtrksel.cfgEtaCut, cfgtrksel.cfgEtaCut); - myTrackFilter.SetMinNCrossedRowsTPC(cfgtrksel.minNCrossedRowsTPC); + myTrackFilter.SetMinNCrossedRowsTPC(static_cast(cfgtrksel.minNCrossedRowsTPC)); myTrackFilter.SetMinNCrossedRowsOverFindableClustersTPC(cfgtrksel.minNCrossedRowsOverFindableClustersTPC); - myTrackFilter.SetMinNClustersTPC(cfgtrksel.minTPCNClsFound); + myTrackFilter.SetMinNClustersTPC(static_cast(cfgtrksel.minTPCNClsFound)); myTrackFilter.SetMaxChi2PerClusterTPC(cfgtrksel.maxChi2PerClusterTPC); myTrackFilter.SetMaxChi2PerClusterITS(cfgtrksel.maxChi2PerClusterITS); myTrackFilter.SetMaxDcaZ(cfgtrksel.maxDcaZ); @@ -333,7 +328,7 @@ struct LongrangeMaker { itsNsigmaCut = itsNsigmaPidCut; tpcNsigmaCut = tpcNsigmaPidCut; - cfgSgCuts = (SGCutParHolder)sgCuts; + cfgSgCuts = SGCutParHolder(sgCuts); } Produces lrmccollision; @@ -364,7 +359,7 @@ struct LongrangeMaker { using TrksTable = soa::Filtered>; using BCs = soa::Join; - std::vector ft0gainvalues{}; + std::vector ft0gainvalues; void processData(CollTable::iterator const& col, TrksTable const& tracks, aod::FT0s const&, @@ -404,10 +399,12 @@ struct LongrangeMaker { // track loop for (const auto& track : tracks) { - if (!track.isGlobalTrack()) + if (!track.isGlobalTrack()) { continue; - if (!myTrackFilter.IsSelected(track)) + } + if (!myTrackFilter.IsSelected(track)) { continue; + } auto pid = getTrackPID(track); lrmidtracks(lrcollision.lastIndex(), track.tpcNClsFound(), @@ -584,9 +581,10 @@ struct LongrangeMaker { histos.fill(HIST("hSelectionResult"), isSGEvent.value); if (issgevent <= cfgGapSide) { - if (cfgSgCuts.minRgtrwTOF()) { - if (udhelpers::rPVtrwTOF(tracks, col.numContrib()) < cfgSgCuts.minRgtrwTOF()) + if (cfgSgCuts.minRgtrwTOF() != 0.0f) { + if (udhelpers::rPVtrwTOF(tracks, col.numContrib()) < cfgSgCuts.minRgtrwTOF()) { return; + } } upchelpers::FITInfo fitInfo{}; @@ -603,10 +601,12 @@ struct LongrangeMaker { // track loop for (const auto& track : tracks) { - if (!track.isGlobalTrack()) + if (!track.isGlobalTrack()) { continue; - if (!myTrackFilter.IsSelected(track)) + } + if (!myTrackFilter.IsSelected(track)) { continue; + } auto pid = getTrackPID(track); upclrmidtracks(upclrcollision.lastIndex(), track.tpcNClsFound(), @@ -732,8 +732,9 @@ struct LongrangeMaker { { auto multiplicity = 0; for (const auto& particle : mcparticles) { - if (!isGenPartSelected(particle) || std::abs(particle.eta()) > cfgtrksel.cfgEtaCut || particle.pt() < cfgtrksel.cfgPtCutMinForMult || particle.pt() > cfgtrksel.cfgPtCutMaxForMult) + if (!isGenPartSelected(particle) || std::abs(particle.eta()) > cfgtrksel.cfgEtaCut || particle.pt() < cfgtrksel.cfgPtCutMinForMult || particle.pt() > cfgtrksel.cfgPtCutMaxForMult) { continue; + } multiplicity++; } lrmccollision(mcCollision.posZ(), multiplicity, mcCollision.multMCFT0A(), mcCollision.multMCFT0C()); @@ -771,15 +772,19 @@ struct LongrangeMaker { // track loop for (const auto& track : recTracksPart) { - if (!track.isGlobalTrack()) + if (!track.isGlobalTrack()) { continue; - if (!myTrackFilter.IsSelected(track)) + } + if (!myTrackFilter.IsSelected(track)) { continue; - if (!track.has_mcParticle()) + } + if (!track.has_mcParticle()) { continue; + } auto mcpart = track.mcParticle(); - if (RecCol.mcCollisionId() != mcpart.mcCollisionId()) + if (RecCol.mcCollisionId() != mcpart.mcCollisionId()) { continue; + } auto pid = getTrackPID(track); lrmidtracks(lrcollision.lastIndex(), track.tpcNClsFound(), @@ -881,13 +886,16 @@ struct LongrangeMaker { continue; } // Fill midrapidity tracks - if (std::abs(particle.eta()) < cfgtrksel.cfgEtaCut && particle.pt() > cfgtrksel.cfgPtCutMin && particle.pt() < cfgtrksel.cfgPtCutMax) + if (std::abs(particle.eta()) < cfgtrksel.cfgEtaCut && particle.pt() > cfgtrksel.cfgPtCutMin && particle.pt() < cfgtrksel.cfgPtCutMax) { lrmidmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi(), particle.pdgCode(), particle.flags()); + } // Fill FT0 tracks - if (cfgfittrksel.cfgFt0aEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0aEtaMax) + if (cfgfittrksel.cfgFt0aEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0aEtaMax) { lrft0amctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); - if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) + } + if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) { lrft0cmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); + } } } } @@ -898,14 +906,18 @@ struct LongrangeMaker { auto multMCFT0A = 0; auto multMCFT0C = 0; for (const auto& particle : mcparticles) { - if (!isGenPartSelected(particle)) + if (!isGenPartSelected(particle)) { continue; - if (std::abs(particle.eta()) < cfgtrksel.cfgEtaCut && particle.pt() > cfgtrksel.cfgPtCutMinForMult && particle.pt() < cfgtrksel.cfgPtCutMaxForMult) + } + if (std::abs(particle.eta()) < cfgtrksel.cfgEtaCut && particle.pt() > cfgtrksel.cfgPtCutMinForMult && particle.pt() < cfgtrksel.cfgPtCutMaxForMult) { multiplicity++; - if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) + } + if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) { multMCFT0C++; - if (cfgfittrksel.cfgFt0aEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0aEtaMax) + } + if (cfgfittrksel.cfgFt0aEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0aEtaMax) { multMCFT0A++; + } } lrmccollision(mcCollision.posZ(), multiplicity, multMCFT0A, multMCFT0C); @@ -914,13 +926,16 @@ struct LongrangeMaker { continue; } // Fill midrapidity tracks - if (std::abs(particle.eta()) < cfgtrksel.cfgEtaCut && particle.pt() > cfgtrksel.cfgPtCutMin && particle.pt() < cfgtrksel.cfgPtCutMax) + if (std::abs(particle.eta()) < cfgtrksel.cfgEtaCut && particle.pt() > cfgtrksel.cfgPtCutMin && particle.pt() < cfgtrksel.cfgPtCutMax) { lrmidmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi(), particle.pdgCode(), particle.flags()); + } // Fill FT0 tracks - if (cfgfittrksel.cfgFt0aEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0aEtaMax) + if (cfgfittrksel.cfgFt0aEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0aEtaMax) { lrft0amctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); - if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) + } + if (cfgfittrksel.cfgFt0cEtaMin < particle.eta() && particle.eta() < cfgfittrksel.cfgFt0cEtaMax) { lrft0cmctracks(lrmccollision.lastIndex(), particle.pt(), particle.eta(), particle.phi()); + } } } @@ -935,9 +950,9 @@ struct LongrangeMaker { multiplicity = countNTracks(tracks, col.posZ()); } - bool checkK0s = (cfgv0trksel.cfgQAV0Mask & 1); - bool checkLam = (cfgv0trksel.cfgQAV0Mask & 2); - bool checkALam = (cfgv0trksel.cfgQAV0Mask & 4); + bool checkK0s = (cfgv0trksel.cfgQAV0Mask & 1) != 0; + bool checkLam = (cfgv0trksel.cfgQAV0Mask & 2) != 0; + bool checkALam = (cfgv0trksel.cfgQAV0Mask & 4) != 0; for (const auto& v0 : V0s) { if (!isSelectV0Track(v0)) { @@ -1091,16 +1106,19 @@ struct LongrangeMaker { { float nTrk = 0.f; for (const auto& track : tracks) { - if (!track.isGlobalTrack()) + if (!track.isGlobalTrack()) { continue; - if (!myTrackFilter.IsSelected(track)) + } + if (!myTrackFilter.IsSelected(track)) { continue; + } if (track.pt() < cfgtrksel.cfgPtCutMinForMult || track.pt() > cfgtrksel.cfgPtCutMaxForMult) { continue; } float trkeff = 1.0f; - if (cfgtrksel.applyEffCorr) + if (cfgtrksel.applyEffCorr) { trkeff = getTrkEffCorr(vz, track.eta(), track.pt()); + } nTrk += trkeff; } return nTrk; @@ -1134,7 +1152,9 @@ struct LongrangeMaker { std::array nSigmaITS = {itsResponse.nSigmaITS(track), itsResponse.nSigmaITS(track), itsResponse.nSigmaITS(track)}; std::array nSigmaToUse = isUseItsPid ? nSigmaITS : nSigmaTPC; // Choose which nSigma to use: TPC or ITS std::vector detectorNsigmaCut = isUseItsPid ? itsNsigmaCut : tpcNsigmaCut; // Choose which nSigma to use: TPC or ITS - bool isPion, isKaon, isProton; + bool isPion = false; + bool isKaon = false; + bool isProton = false; bool isDetectedPion = nSigmaToUse[0] < detectorNsigmaCut[0] && nSigmaToUse[0] > detectorNsigmaCut[0 + 3]; bool isDetectedKaon = nSigmaToUse[1] < detectorNsigmaCut[1] && nSigmaToUse[1] > detectorNsigmaCut[1 + 3]; bool isDetectedProton = nSigmaToUse[2] < detectorNsigmaCut[2] && nSigmaToUse[2] > detectorNsigmaCut[2 + 3]; @@ -1145,7 +1165,8 @@ struct LongrangeMaker { if (track.pt() > cfgTofPidPtCut && !track.hasTOF()) { return aod::lrcorrtrktable::kNoPid; - } else if (track.pt() > cfgTofPidPtCut && track.hasTOF()) { + } + if (track.pt() > cfgTofPidPtCut && track.hasTOF()) { isPion = isTofPion && isDetectedPion; isKaon = isTofKaon && isDetectedKaon; isProton = isTofProton && isDetectedProton; @@ -1161,31 +1182,33 @@ struct LongrangeMaker { if (isPion) { return aod::lrcorrtrktable::kSpPion; - } else if (isKaon) { + } + if (isKaon) { return aod::lrcorrtrktable::kSpKaon; - } else if (isProton) { + } + if (isProton) { return aod::lrcorrtrktable::kSpProton; - } else { - return aod::lrcorrtrktable::kNoPid; // no particle satisfies the criteria } + return aod::lrcorrtrktable::kNoPid; // no particle satisfies the criteria } int getFt0aDeadChannelId(int channelId) { - if (channelId >= MinFt0aMirrorChannelOuter && channelId <= MaxFt0aMirrorChannelOuter) + if (channelId >= MinFt0aMirrorChannelOuter && channelId <= MaxFt0aMirrorChannelOuter) { return MinFt0aDeadChannelOuter + (channelId - MinFt0aMirrorChannelOuter); - else - return -1; + } + return -1; } int getFt0cDeadChannelId(int channelId) { - if (channelId >= MinFt0cMirrorChannelOuter && channelId <= MaxFt0cMirrorChannelOuter) + if (channelId >= MinFt0cMirrorChannelOuter && channelId <= MaxFt0cMirrorChannelOuter) { return MinFt0cDeadChannelOuter + (channelId - MinFt0cMirrorChannelOuter); - else if (channelId == Ft0cMirrorChannelInner) + } + if (channelId == Ft0cMirrorChannelInner) { return Ft0cDeadChannelInner; - else - return -1; + } + return -1; } double getPhiFT0(uint chno, int i) @@ -1202,8 +1225,9 @@ struct LongrangeMaker { auto x = chPos.X() + (*offsetFT0)[i].getX(); auto y = chPos.Y() + (*offsetFT0)[i].getY(); auto z = chPos.Z() + (*offsetFT0)[i].getZ(); - if (chno >= KminFt0cCell) + if (chno >= KminFt0cCell) { z = -z; + } auto r = std::sqrt(x * x + y * y); auto theta = std::atan2(r, z); return -std::log(std::tan(0.5 * theta)); @@ -1337,7 +1361,7 @@ struct LongrangeMaker { if (fLoadTrkEffCorr) { return; } - if (cfgtrksel.cfgEffccdbPath.value.empty() == false) { + if (!cfgtrksel.cfgEffccdbPath.value.empty()) { hTrkEff = ccdb->getForTimeStamp(cfgtrksel.cfgEffccdbPath, timestamp); if (hTrkEff == nullptr) { LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfgtrksel.cfgEffccdbPath.value.c_str()); @@ -1369,8 +1393,8 @@ struct LongrangeMaker { PROCESS_SWITCH(LongrangeMaker, processV0QA, "process V0 QA histograms", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +WorkflowSpec defineDataProcessing(ConfigContext const& context) { return WorkflowSpec{ - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(context)}; } From 589f2d098591fa3cca19ea5832e809b495cbe038 Mon Sep 17 00:00:00 2001 From: Soumyadip Ghosh Date: Mon, 9 Nov 2026 18:57:02 +0530 Subject: [PATCH 5/5] Refactor condition checks for efficiency and selection --- .../Tasks/longrangecorrDerived.cxx | 178 +++++++++++------- 1 file changed, 112 insertions(+), 66 deletions(-) diff --git a/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx b/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx index 805e03a250f..22eeaebfdf6 100644 --- a/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx +++ b/PWGCF/TwoParticleCorrelations/Tasks/longrangecorrDerived.cxx @@ -24,10 +24,8 @@ #include "Common/Core/RecoDecay.h" #include "Common/Core/TrackSelection.h" #include "Common/Core/TrackSelectionDefaults.h" -#include "Common/DataModel/Centrality.h" #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/McCollisionExtra.h" -#include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/PIDResponseTOF.h" #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/TrackSelectionTables.h" @@ -380,7 +378,7 @@ struct LongrangecorrDerived { if (fLoadTrkEffCorr) { return; } - if (cfgSel.cfgEffccdbPath.value.empty() == false) { + if (!cfgSel.cfgEffccdbPath.value.empty()) { hTrkEff = ccdb->getForTimeStamp(cfgSel.cfgEffccdbPath, timestamp); if (hTrkEff == nullptr) { LOGF(fatal, "Could not load efficiency histogram for trigger particles from %s", cfgSel.cfgEffccdbPath.value.c_str()); @@ -388,7 +386,7 @@ struct LongrangecorrDerived { LOGF(info, "Loaded efficiency histogram from %s (%p)", cfgSel.cfgEffccdbPath.value.c_str(), static_cast(hTrkEff)); } - if (cfgSel.cfgAccccdbPath.value.empty() == false) { + if (!cfgSel.cfgAccccdbPath.value.empty()) { hTrkAcc = ccdb->getForTimeStamp(cfgSel.cfgAccccdbPath, timestamp); if (hTrkAcc == nullptr) { LOGF(fatal, "Could not load NUA histogram for trigger particles from %s", cfgSel.cfgAccccdbPath.value.c_str()); @@ -433,14 +431,18 @@ struct LongrangecorrDerived { bool isTrackSelected(TTrack const& track) { if constexpr (requires { track.tpcNClsFound(); }) { - if (track.tpcNClsFound() < cfgSel.cfgTpcMinNclsFound) + if (track.tpcNClsFound() < cfgSel.cfgTpcMinNclsFound) { return false; - if (track.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows) + } + if (track.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows) { return false; - if (track.tpcChi2NCl() > cfgSel.cfgTpcMaxChi2PerCluster) + } + if (track.tpcChi2NCl() > cfgSel.cfgTpcMaxChi2PerCluster) { return false; - if (std::abs(track.dcaZ()) > cfgSel.cfgTpcMaxDcaZ) + } + if (std::abs(track.dcaZ()) > cfgSel.cfgTpcMaxDcaZ) { return false; + } return true; } else { return true; @@ -505,8 +507,9 @@ struct LongrangecorrDerived { if constexpr (fillHist) { histos.fill(HIST("hTrueGapSide"), truegapSide); } - if (truegapSide != cfgGapSideCut) + if (truegapSide != cfgGapSideCut) { return false; + } if constexpr (fillHist) { histos.fill(HIST("hTrueGapSide_AfterSel"), truegapSide); } @@ -522,22 +525,27 @@ struct LongrangecorrDerived { auto trkeff = 1.0f; auto trkAcc = 1.0f; - if (!isTrackSelected(triggerTrack)) + if (!isTrackSelected(triggerTrack)) { continue; + } if constexpr (requires { triggerTrack.trackType(); }) { - if (cfgSel.cfgPidMask != 0 && (cfgSel.cfgPidMask & (1u << static_cast(triggerTrack.trackType()))) == 0u) + if (cfgSel.cfgPidMask != 0 && (cfgSel.cfgPidMask & (1u << static_cast(triggerTrack.trackType()))) == 0u) { continue; + } } else if constexpr (requires { triggerTrack.v0Type(); }) { - if (cfgSel.cfgV0Mask != 0 && (cfgSel.cfgV0Mask & (1u << static_cast(triggerTrack.v0Type()))) == 0u) + if (cfgSel.cfgV0Mask != 0 && (cfgSel.cfgV0Mask & (1u << static_cast(triggerTrack.v0Type()))) == 0u) { continue; + } } if constexpr (requires { triggerTrack.channelID(); }) { - if (cfgSel.cfgRequireFt0aOuterRing && !triggerTrack.isTrackFT0Outer()) + if (cfgSel.cfgRequireFt0aOuterRing && !triggerTrack.isTrackFT0Outer()) { continue; - if (cfgSel.cfgRequireFt0aInnerRing && triggerTrack.isTrackFT0Outer()) + } + if (cfgSel.cfgRequireFt0aInnerRing && triggerTrack.isTrackFT0Outer()) { continue; + } trigAmpl = triggerTrack.amplitude(); } else { trigAmpl = 1.0; @@ -570,14 +578,17 @@ struct LongrangecorrDerived { for (auto const& assoTrack : assocs) { auto assoAmpl = 1.0f; - if (!isTrackSelected(assoTrack)) + if (!isTrackSelected(assoTrack)) { continue; + } if constexpr (requires { assoTrack.channelID(); }) { - if (cfgSel.cfgRequireFt0cOuterRing && !assoTrack.isTrackFT0Outer()) + if (cfgSel.cfgRequireFt0cOuterRing && !assoTrack.isTrackFT0Outer()) { continue; - if (cfgSel.cfgRequireFt0cInnerRing && assoTrack.isTrackFT0Outer()) + } + if (cfgSel.cfgRequireFt0cInnerRing && assoTrack.isTrackFT0Outer()) { continue; + } assoAmpl = assoTrack.amplitude(); } else { assoAmpl = 1.0f; @@ -612,10 +623,11 @@ struct LongrangecorrDerived { fillCollQA(col); auto multiplicity = 1.0f; if constexpr (requires { col.centrality(); }) { - if (cfgSel.isUseCentEst) + if (cfgSel.isUseCentEst) { multiplicity = col.centrality(); - else + } else { multiplicity = col.multiplicity(); + } } else { multiplicity = col.multiplicity(); } @@ -639,10 +651,11 @@ struct LongrangecorrDerived { } auto multiplicity = 1.0f; if constexpr (requires { col.centrality(); }) { - if (cfgSel.isUseCentEst) + if (cfgSel.isUseCentEst) { multiplicity = col.centrality(); - else + } else { multiplicity = col.multiplicity(); + } } else { multiplicity = col.multiplicity(); } @@ -691,10 +704,11 @@ struct LongrangecorrDerived { auto multiplicity = mccollision.multiplicity(); if (cfgSel.isUseDataLikeMult > 0) { for (const auto& collision : collisions) { - if (cfgSel.isUseCentEst) + if (cfgSel.isUseCentEst) { multiplicity = collision.centrality(); - else + } else { multiplicity = collision.multiplicity(); + } } } fillCorrHist(same, triggers, assocs, false, mccollision.posZ(), multiplicity, 1.0); @@ -706,15 +720,17 @@ struct LongrangecorrDerived { bool useMCMultiplicity = (cfgSel.isUseDataLikeMult == 0); auto getMultiplicity = [&collisions, &useMCMultiplicity, this](auto& col) { - if (useMCMultiplicity) + if (useMCMultiplicity) { return col.multiplicity(); + } auto groupedCollisions = collisions.sliceByCached(aod::lrcorrcolltable::lrMcCollisionId, col.globalIndex(), this->cache); - if (groupedCollisions.size() == 0) + if (groupedCollisions.size() == 0) { return -1.0f; - if (cfgSel.isUseCentEst) + } + if (cfgSel.isUseCentEst) { return groupedCollisions.begin().centrality(); - else - return groupedCollisions.begin().multiplicity(); + } + return groupedCollisions.begin().multiplicity(); }; using MixedBinning = FlexibleBinningPolicy, aod::mccollision::PosZ, decltype(getMultiplicity)>; @@ -960,29 +976,37 @@ struct LongrangecorrDerived { template bool isEventSelected(CheckCol const& col) { - if (!col.sel8()) + if (!col.sel8()) { return false; - if (!col.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) + } + if (!col.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) { return false; - if (!col.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) + } + if (!col.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) { return false; - if (!col.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) + } + if (!col.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) { return false; - if (std::abs(col.posZ()) >= cfgSel.cfgVtxCut) + } + if (std::abs(col.posZ()) >= cfgSel.cfgVtxCut) { return false; + } return true; } template bool isGenPartSelected(CheckGenPart const& particle) { - if (!particle.isPhysicalPrimary() || !particle.producedByGenerator()) + if (!particle.isPhysicalPrimary() || !particle.producedByGenerator()) { return false; + } auto pdgParticle = pdg->GetParticle(particle.pdgCode()); - if (pdgParticle == nullptr) + if (pdgParticle == nullptr) { return false; - if (std::abs(pdgParticle->Charge()) < KminCharge) + } + if (std::abs(pdgParticle->Charge()) < KminCharge) { return false; + } return true; } @@ -994,18 +1018,21 @@ struct LongrangecorrDerived { } bool atLeastOne = false; for (const auto& RecCol : RecCols) { - if (!isEventSelected(RecCol)) + if (!isEventSelected(RecCol)) { continue; - if (RecCol.globalIndex() != mcCollision.bestCollisionIndex()) + } + if (RecCol.globalIndex() != mcCollision.bestCollisionIndex()) { continue; + } atLeastOne = true; } for (const auto& particle : mcparticles) { if (!isGenPartSelected(particle) || std::abs(particle.eta()) > cfgSel.cfgEtaCut || particle.pt() < cfgSel.cfgPtCutMin || - particle.pt() > cfgSel.cfgPtCutMax) + particle.pt() > cfgSel.cfgPtCutMax) { continue; + } if (atLeastOne) { histos.fill(HIST("hGenMCdndpt"), mcCollision.posZ(), particle.eta(), particle.pt()); @@ -1024,21 +1051,27 @@ struct LongrangecorrDerived { } for (const auto& RecCol : RecCols) { - if (!isEventSelected(RecCol)) + if (!isEventSelected(RecCol)) { continue; - if (RecCol.globalIndex() != mcCollision.bestCollisionIndex()) + } + if (RecCol.globalIndex() != mcCollision.bestCollisionIndex()) { continue; + } auto recTracksPart = RecTracks.sliceBy(perColMidtrack, RecCol.globalIndex()); for (const auto& track : recTracksPart) { - if (!track.isGlobalTrack()) + if (!track.isGlobalTrack()) { continue; - if (!myTrackFilter.IsSelected(track)) + } + if (!myTrackFilter.IsSelected(track)) { continue; - if (!track.has_mcParticle()) + } + if (!track.has_mcParticle()) { continue; + } auto particle = track.mcParticle(); - if (RecCol.mcCollisionId() != particle.mcCollisionId()) + if (RecCol.mcCollisionId() != particle.mcCollisionId()) { continue; + } if (particle.isPhysicalPrimary()) { histos.fill(HIST("hRecMCdndpt"), mcCollision.posZ(), particle.eta(), particle.pt()); @@ -1089,7 +1122,7 @@ struct LongrangecorrDerived { isPion = isTofPion && isTpcPion; isKaon = isTofKaon && isTpcKaon; isProton = isTofProton && isTpcProton; - } else if (!(track.pt() > cfgSel.cfgTofPidPtCut && !track.hasTOF())) { + } else if (track.pt() <= cfgSel.cfgTofPidPtCut || track.hasTOF()) { isPion = isTpcPion; isKaon = isTpcKaon; isProton = isTpcProton; @@ -1123,12 +1156,15 @@ struct LongrangecorrDerived { { float nTrk = 0.0f; for (auto const& trk : tracks) { - if (!trk.isGlobalTrack()) + if (!trk.isGlobalTrack()) { continue; - if (!myTrackFilter.IsSelected(trk)) + } + if (!myTrackFilter.IsSelected(trk)) { continue; - if (trk.pt() < cfgSel.cfgPtCutMinForMult || trk.pt() > cfgSel.cfgPtCutMaxForMult) + } + if (trk.pt() < cfgSel.cfgPtCutMinForMult || trk.pt() > cfgSel.cfgPtCutMaxForMult) { continue; + } nTrk += getTrkEffCorr(vz, trk.eta(), trk.pt()); } return nTrk; @@ -1137,24 +1173,31 @@ struct LongrangecorrDerived { template void fillCleanV0Daughters(TCollision const& rawCol, TV0 const& v0, TTrack const& posTrack, TTrack const& negTrack, float multiplicity) { - if (!posTrack.hasTPC() || !negTrack.hasTPC()) + if (!posTrack.hasTPC() || !negTrack.hasTPC()) { return; - if (posTrack.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows || negTrack.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows) + } + if (posTrack.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows || negTrack.tpcNClsCrossedRows() < cfgSel.cfgTpcMinNCrossedRows) { return; - if (std::abs(v0.positiveeta()) > cfgSel.cfgEtaCut || std::abs(v0.negativeeta()) > cfgSel.cfgEtaCut) + } + if (std::abs(v0.positiveeta()) > cfgSel.cfgEtaCut || std::abs(v0.negativeeta()) > cfgSel.cfgEtaCut) { return; - if (v0.v0cosPA() < cfgSel.cfgCleanV0MinCosPA) + } + if (v0.v0cosPA() < cfgSel.cfgCleanV0MinCosPA) { return; - if (v0.dcaV0daughters() > cfgSel.cfgCleanV0MaxDcaDau) + } + if (v0.dcaV0daughters() > cfgSel.cfgCleanV0MaxDcaDau) { return; - if (v0.v0radius() < cfgSel.cfgCleanV0MinRadius || v0.v0radius() > cfgSel.cfgCleanV0MaxRadius) + } + if (v0.v0radius() < cfgSel.cfgCleanV0MinRadius || v0.v0radius() > cfgSel.cfgCleanV0MaxRadius) { return; + } float distOverP = v0.distovertotmom(rawCol.posX(), rawCol.posY(), rawCol.posZ()); auto fillV0Probe = [&](double v0CleanType, TTrack const& probeTrack, float tpcNsig, float tofNsigReal, float expSigma, bool isPionProbe, bool isProtonProbe) { - if (!probeTrack.isGlobalTrack() || !myTrackFilter.IsSelected(probeTrack)) + if (!probeTrack.isGlobalTrack() || !myTrackFilter.IsSelected(probeTrack)) { return; + } const float tofVal = probeTrack.hasTOF() ? tofNsigReal : -999.0f; @@ -1166,8 +1209,8 @@ struct LongrangecorrDerived { if (cfgSel.cfgFillAfterCutWithV0 && cfgSel.cfgGetNsigmaQA) { const bool passTofForAfterCut = !cfgSel.cfgRequireTofForV0AfterCut || (probeTrack.hasTOF() && tofNsigReal > cfgSel.cfgCleanNsigmaTofMin && tofNsigReal < cfgSel.cfgCleanNsigmaTofMax); - const bool matchWagon = ((cfgSel.cfgPidMask & KPidMaskPion) && isPionProbe) || - ((cfgSel.cfgPidMask & KPidMaskProton) && isProtonProbe); + const bool matchWagon = (((cfgSel.cfgPidMask & KPidMaskPion) != 0) && isPionProbe) || + (((cfgSel.cfgPidMask & KPidMaskProton) != 0) && isProtonProbe); if (matchWagon && passTofForAfterCut) { histos.fill(HIST("TofTpcNsigma_after"), multiplicity, probeTrack.pt(), tpcNsig, tofVal); if (cfgSel.cfgGetdEdx) { @@ -1273,12 +1316,15 @@ struct LongrangecorrDerived { auto tracks = standardTracks.sliceByCached(aod::track::collisionId, rawCol.globalIndex(), this->cache); for (auto const& track : tracks) { - if (!track.isGlobalTrack()) + if (!track.isGlobalTrack()) { continue; - if (!myTrackFilter.IsSelected(track)) + } + if (!myTrackFilter.IsSelected(track)) { continue; - if (!track.hasTOF()) + } + if (!track.hasTOF()) { continue; + } const float tpcNsigPi = track.tpcNSigmaPi(), tofNsigPi = track.tofNSigmaPi(), expSigPi = track.tpcExpSigmaPi(); const float tpcNsigKa = track.tpcNSigmaKa(), tofNsigKa = track.tofNSigmaKa(), expSigKa = track.tpcExpSigmaKa(); @@ -1326,17 +1372,17 @@ struct LongrangecorrDerived { float tpcNsig = 0.0f, tofNsig = 0.0f, expSig = 0.0f; bool isTargetClean = false; - if (cfgSel.cfgPidMask & KPidMaskPion) { + if ((cfgSel.cfgPidMask & KPidMaskPion) != 0) { tpcNsig = tpcNsigPi; tofNsig = tofNsigPi; expSig = expSigPi; isTargetClean = isCleanPi; - } else if (cfgSel.cfgPidMask & KPidMaskKaon) { + } else if ((cfgSel.cfgPidMask & KPidMaskKaon) != 0) { tpcNsig = tpcNsigKa; tofNsig = tofNsigKa; expSig = expSigKa; isTargetClean = isCleanKa; - } else if (cfgSel.cfgPidMask & KPidMaskProton) { + } else if ((cfgSel.cfgPidMask & KPidMaskProton) != 0) { tpcNsig = tpcNsigPr; tofNsig = tofNsigPr; expSig = expSigPr; @@ -1413,8 +1459,8 @@ struct LongrangecorrDerived { PROCESS_SWITCH(LongrangecorrDerived, processPIDQA, "process PID QA on standard AODs", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +WorkflowSpec defineDataProcessing(ConfigContext const& context) { return WorkflowSpec{ - adaptAnalysisTask(cfgc)}; + adaptAnalysisTask(context)}; }