From 924cc700056d3aade6cd429d5d99b5e096f97656 Mon Sep 17 00:00:00 2001 From: skundu692 Date: Mon, 26 Jan 2026 20:25:57 +0100 Subject: [PATCH] Add additional track info for systematics --- PWGLF/DataModel/ReducedF1ProtonTables.h | 54 ++++++- .../Resonances/f1protonreducedtable.cxx | 135 +++++++++++++++++- .../Tasks/Resonances/f1protoncorrelation.cxx | 2 +- 3 files changed, 185 insertions(+), 6 deletions(-) diff --git a/PWGLF/DataModel/ReducedF1ProtonTables.h b/PWGLF/DataModel/ReducedF1ProtonTables.h index 992a0eb547a..108df966bb1 100644 --- a/PWGLF/DataModel/ReducedF1ProtonTables.h +++ b/PWGLF/DataModel/ReducedF1ProtonTables.h @@ -77,6 +77,31 @@ DECLARE_SOA_COLUMN(ProtonNsigmaTPC, protonNsigmaTPC, float); //! P DECLARE_SOA_COLUMN(ProtonTOFHit, protonTOFHit, int); //! Proton TOF Hit DECLARE_SOA_COLUMN(ProtonNsigmaTOF, protonNsigmaTOF, float); //! Proton TOF nsigma DECLARE_SOA_COLUMN(F1ProtonIndex, f1ProtonIndex, int64_t); //! F1 proton index +DECLARE_SOA_COLUMN(PionTOF, pionTOF, float); //! Pion TOF +DECLARE_SOA_COLUMN(PionDcaxy, pionDcaxy, float); //! Pion DCAxy +DECLARE_SOA_COLUMN(PionDcaz, pionDcaz, float); //! Pion DCAz +DECLARE_SOA_COLUMN(PionTPCNcls, pionTPCNcls, float); //! Pion TPC Ncls +DECLARE_SOA_COLUMN(PionTPCNcrs, pionTPCNcrs, float); //! Pion TPC Ncrs +DECLARE_SOA_COLUMN(KaonTOF, kaonTOF, float); //! Kaon TOF +DECLARE_SOA_COLUMN(KaonDcaxy, kaonDcaxy, float); //! Kaon DCAxy +DECLARE_SOA_COLUMN(KaonDcaz, kaonDcaz, float); //! Kaon DCAz +DECLARE_SOA_COLUMN(KaonTPCNcls, kaonTPCNcls, float); //! Kaon TPC Ncls +DECLARE_SOA_COLUMN(KaonTPCNcrs, kaonTPCNcrs, float); //! Kaon TPC Ncrs +DECLARE_SOA_COLUMN(K0D1Dcaxy, k0D1Dcaxy, float); //! K0 daughter 1 DCAxy +DECLARE_SOA_COLUMN(K0D1TPCNcls, k0D1TPCNcls, float); //! K0 daughter 1 TPC Ncls +DECLARE_SOA_COLUMN(K0D1TPCNcrs, k0D1TPCNcrs, float); //! K0 daughter 1 TPC Ncrs +DECLARE_SOA_COLUMN(K0D2Dcaxy, k0D2Dcaxy, float); //! K0 daughter 2 DCAxy +DECLARE_SOA_COLUMN(K0D2TPCNcls, k0D2TPCNcls, float); //! K0 daughter 2 TPC Ncls +DECLARE_SOA_COLUMN(K0D2TPCNcrs, k0D2TPCNcrs, float); //! K0 daughter 2 TPC Ncrs +DECLARE_SOA_COLUMN(K0Cpa, k0Cpa, float); //! K0 CPA +DECLARE_SOA_COLUMN(K0Radius, k0Radius, float); //! K0 decay radius +DECLARE_SOA_COLUMN(K0DcaDaughters, k0DcaDaughters, float); //! K0 DCA between daughters +DECLARE_SOA_COLUMN(K0Dca, k0Dca, float); //! K0 DCA to PV +DECLARE_SOA_COLUMN(K0LifeTime, k0LifeTime, float); //! K0 proper lifetime +DECLARE_SOA_COLUMN(ProtonDcaxy, protonDcaxy, float); //! Proton DCAxy +DECLARE_SOA_COLUMN(ProtonDcaz, protonDcaz, float); //! Proton DCAz +DECLARE_SOA_COLUMN(ProtonTPCNcls, protonTPCNcls, float); //! Proton TPC Ncls +DECLARE_SOA_COLUMN(ProtonTPCNcrs, protonTPCNcrs, float); //! Proton TPC Ncrs } // namespace f1protondaughter DECLARE_SOA_TABLE(F1Tracks, "AOD", "F1TRACK", o2::soa::Index<>, @@ -104,7 +129,28 @@ DECLARE_SOA_TABLE(F1Tracks, "AOD", "F1TRACK", f1protondaughter::F1PionIndex, f1protondaughter::F1KaonIndex, f1protondaughter::F1KshortPositiveIndex, - f1protondaughter::F1KshortNegativeIndex); + f1protondaughter::F1KshortNegativeIndex, + f1protondaughter::PionTOF, + f1protondaughter::PionDcaxy, + f1protondaughter::PionDcaz, + f1protondaughter::PionTPCNcls, + f1protondaughter::PionTPCNcrs, + f1protondaughter::KaonTOF, + f1protondaughter::KaonDcaxy, + f1protondaughter::KaonDcaz, + f1protondaughter::KaonTPCNcls, + f1protondaughter::KaonTPCNcrs, + f1protondaughter::K0D1Dcaxy, + f1protondaughter::K0D1TPCNcls, + f1protondaughter::K0D1TPCNcrs, + f1protondaughter::K0D2Dcaxy, + f1protondaughter::K0D2TPCNcls, + f1protondaughter::K0D2TPCNcrs, + f1protondaughter::K0Cpa, + f1protondaughter::K0Radius, + f1protondaughter::K0DcaDaughters, + f1protondaughter::K0Dca, + f1protondaughter::K0LifeTime); using F1Track = F1Tracks::iterator; DECLARE_SOA_TABLE(ProtonTracks, "AOD", "PROTONTRACK", @@ -117,7 +163,11 @@ DECLARE_SOA_TABLE(ProtonTracks, "AOD", "PROTONTRACK", f1protondaughter::ProtonNsigmaTPC, f1protondaughter::ProtonTOFHit, f1protondaughter::ProtonNsigmaTOF, - f1protondaughter::F1ProtonIndex); + f1protondaughter::F1ProtonIndex, + f1protondaughter::ProtonDcaxy, + f1protondaughter::ProtonDcaz, + f1protondaughter::ProtonTPCNcls, + f1protondaughter::ProtonTPCNcrs); using ProtonTrack = ProtonTracks::iterator; } // namespace o2::aod #endif // PWGLF_DATAMODEL_REDUCEDF1PROTONTABLES_H_ diff --git a/PWGLF/TableProducer/Resonances/f1protonreducedtable.cxx b/PWGLF/TableProducer/Resonances/f1protonreducedtable.cxx index 7727987a5d7..4cbdecef436 100644 --- a/PWGLF/TableProducer/Resonances/f1protonreducedtable.cxx +++ b/PWGLF/TableProducer/Resonances/f1protonreducedtable.cxx @@ -556,12 +556,16 @@ struct f1protonreducedtable { std::vector PionTOFHitFinal = {}; std::vector PionTPC = {}; std::vector PionTPCFinal = {}; + std::vector PionTOFNsigma = {}; + std::vector PionTOFNsigmaFinal = {}; // keep TOF Hit of kaon std::vector KaonTOFHit = {}; std::vector KaonTOFHitFinal = {}; std::vector KaonTPC = {}; std::vector KaonTPCFinal = {}; + std::vector KaonTOFNsigma = {}; + std::vector KaonTOFNsigmaFinal = {}; std::vector KaonTPCPionHypo = {}; std::vector KaonTPCPionHypoFinal = {}; @@ -571,6 +575,68 @@ struct f1protonreducedtable { // keep status of F1 signal unlike or wrong sign std::vector f1signal = {}; + // keep track dcaxy + std::vector PionDcaxy = {}; + std::vector KaonDcaxy = {}; + std::vector ProtonDcaxy = {}; + std::vector K0D1Dcaxy = {}; + std::vector K0D2Dcaxy = {}; + + // keep track ncls + std::vector PionTPCNcls = {}; + std::vector KaonTPCNcls = {}; + std::vector ProtonTPCNcls = {}; + std::vector K0D1TPCNcls = {}; + std::vector K0D2TPCNcls = {}; + + // keep track ncrs + std::vector PionTPCNcrs = {}; + std::vector KaonTPCNcrs = {}; + std::vector ProtonTPCNcrs = {}; + std::vector K0D1TPCNcrs = {}; + std::vector K0D2TPCNcrs = {}; + + // keep track dcaz + std::vector PionDcaz = {}; + std::vector KaonDcaz = {}; + std::vector ProtonDcaz = {}; + + // keep v0 topology + std::vector K0Cpa = {}; + std::vector K0radius = {}; + std::vector K0DcaBetweenDaughters = {}; + std::vector K0Dca = {}; + std::vector K0LifeTime = {}; + + // keep track dcaxy + std::vector PionDcaxyFinal = {}; + std::vector KaonDcaxyFinal = {}; + std::vector K0D1DcaxyFinal = {}; + std::vector K0D2DcaxyFinal = {}; + + // keep track ncls + std::vector PionTPCNclsFinal = {}; + std::vector KaonTPCNclsFinal = {}; + std::vector K0D1TPCNclsFinal = {}; + std::vector K0D2TPCNclsFinal = {}; + + // keep track ncrs + std::vector PionTPCNcrsFinal = {}; + std::vector KaonTPCNcrsFinal = {}; + std::vector K0D1TPCNcrsFinal = {}; + std::vector K0D2TPCNcrsFinal = {}; + + // keep track dcaz + std::vector PionDcazFinal = {}; + std::vector KaonDcazFinal = {}; + + // keep v0 topology + std::vector K0CpaFinal = {}; + std::vector K0radiusFinal = {}; + std::vector K0DcaBetweenDaughtersFinal = {}; + std::vector K0DcaFinal = {}; + std::vector K0LifeTimeFinal = {}; + // Prepare vectors for different species std::vector protons, kaons, pions, kshorts, f1resonance, f1resonanced1, f1resonanced2, f1resonanced3; // , protonsfinal; @@ -649,7 +715,14 @@ struct f1protonreducedtable { pions.push_back(temp); PionIndex.push_back(track.globalIndex()); PionCharge.push_back(track.sign()); + + PionDcaxy.push_back(std::abs(track.dcaXY())); + PionDcaz.push_back(std::abs(track.dcaZ())); + PionTPCNcls.push_back(std::abs(track.tpcNClsFound())); + PionTPCNcrs.push_back(std::abs(track.tpcNClsCrossedRows())); + auto PionTOF = 0; + auto nSigmaPionTOF = -999; if (track.sign() > 0) { qaRegistry.fill(HIST("hNsigmaPtpionTPC"), nTPCSigmaP[0], track.pt()); PionTPC.push_back(nTPCSigmaP[0]); @@ -660,9 +733,11 @@ struct f1protonreducedtable { } if (track.hasTOF()) { qaRegistry.fill(HIST("hNsigmaPtpionTOF"), track.tofNSigmaPi(), track.pt()); + nSigmaPionTOF = track.tofNSigmaPi(); PionTOF = 1; } PionTOFHit.push_back(PionTOF); + PionTOFNsigma.push_back(nSigmaPionTOF); } if ((track.pt() > cMinKaonPt && track.sign() > 0 && SelectionPID(track, strategyPIDKaon, 1, nTPCSigmaP[1]) && (itsResponse.nSigmaITS(track) > -3.0 && itsResponse.nSigmaITS(track) < 3.0)) || (track.pt() > cMinKaonPt && track.sign() < 0 && SelectionPID(track, strategyPIDKaon, 1, nTPCSigmaN[1]) && (itsResponse.nSigmaITS(track) > -3.0 && itsResponse.nSigmaITS(track) < 3.0))) { @@ -670,7 +745,14 @@ struct f1protonreducedtable { kaons.push_back(temp); KaonIndex.push_back(track.globalIndex()); KaonCharge.push_back(track.sign()); + + KaonDcaxy.push_back(std::abs(track.dcaXY())); + KaonDcaz.push_back(std::abs(track.dcaZ())); + KaonTPCNcls.push_back(std::abs(track.tpcNClsFound())); + KaonTPCNcrs.push_back(std::abs(track.tpcNClsCrossedRows())); + auto KaonTOF = 0; + auto nSigmaKaonTOF = -999.0; if (track.sign() > 0) { qaRegistry.fill(HIST("hNsigmaPtkaonTPC"), nTPCSigmaP[1], nTPCSigmaP[0], track.pt()); KaonTPC.push_back(nTPCSigmaP[1]); @@ -684,8 +766,10 @@ struct f1protonreducedtable { if (track.hasTOF()) { qaRegistry.fill(HIST("hNsigmaPtkaonTOF"), track.tofNSigmaKa(), track.pt()); KaonTOF = 1; + nSigmaKaonTOF = track.tofNSigmaKa(); } KaonTOFHit.push_back(KaonTOF); + KaonTOFNsigma.push_back(nSigmaKaonTOF); } if ((track.pt() < cMaxProtonPt && track.sign() > 0 && SelectionPID(track, strategyPIDProton, 2, nTPCSigmaP[2]) && (itsResponse.nSigmaITS(track) > -3.0 && itsResponse.nSigmaITS(track) < 3.0)) || (track.pt() < cMaxProtonPt && track.sign() < 0 && SelectionPID(track, strategyPIDProton, 2, nTPCSigmaN[2]) && (itsResponse.nSigmaITS(track) > -3.0 && itsResponse.nSigmaITS(track) < 3.0))) { @@ -693,6 +777,12 @@ struct f1protonreducedtable { protons.push_back(temp); ProtonIndex.push_back(track.globalIndex()); ProtonCharge.push_back(track.sign()); + + ProtonDcaxy.push_back(std::abs(track.dcaXY())); + ProtonDcaz.push_back(std::abs(track.dcaZ())); + ProtonTPCNcls.push_back(std::abs(track.tpcNClsFound())); + ProtonTPCNcrs.push_back(std::abs(track.tpcNClsCrossedRows())); + if (track.sign() > 0) { qaRegistry.fill(HIST("hNsigmaPtprotonTPC"), nTPCSigmaP[2], track.pt()); ProtonTPCNsigma.push_back(nTPCSigmaP[2]); @@ -707,7 +797,7 @@ struct f1protonreducedtable { ProtonTOFHit.push_back(1); } if (!track.hasTOF()) { - ProtonTOFNsigma.push_back(999.0); + ProtonTOFNsigma.push_back(-999.0); ProtonTOFHit.push_back(0); } } @@ -739,6 +829,20 @@ struct f1protonreducedtable { kshorts.push_back(temp); KshortPosDaughIndex.push_back(postrack.globalIndex()); KshortNegDaughIndex.push_back(negtrack.globalIndex()); + + K0D1Dcaxy.push_back(std::abs(postrack.dcaXY())); + K0D1TPCNcls.push_back(std::abs(postrack.tpcNClsFound())); + K0D1TPCNcrs.push_back(std::abs(postrack.tpcNClsCrossedRows())); + + K0D2Dcaxy.push_back(std::abs(negtrack.dcaXY())); + K0D2TPCNcls.push_back(std::abs(negtrack.tpcNClsFound())); + K0D2TPCNcrs.push_back(std::abs(negtrack.tpcNClsCrossedRows())); + + K0Cpa.push_back(std::abs(v0.v0cosPA())); + K0radius.push_back(std::abs(v0.v0radius())); + K0DcaBetweenDaughters.push_back(std::abs(v0.dcaV0daughters())); + K0LifeTime.push_back(std::abs(v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * TDatabasePDG::Instance()->GetParticle(kK0Short)->Mass())); + K0Dca.push_back(std::abs(v0.dcav0topv())); } if (pions.size() != 0 && kaons.size() != 0 && kshorts.size() != 0) { @@ -792,6 +896,31 @@ struct f1protonreducedtable { PionTPCFinal.push_back(PionTPC.at(i1)); // Pion TPC KaonTPCFinal.push_back(KaonTPC.at(i2)); // Kaon TPC KaonTPCPionHypoFinal.push_back(KaonTPCPionHypo.at(i2)); // Kaon TPC + + // Fill variable for systematic + + PionTOFNsigmaFinal.push_back(PionTOFNsigma.at(i1)); + PionDcaxyFinal.push_back(PionDcaxy.at(i1)); + PionDcazFinal.push_back(PionDcaz.at(i1)); + PionTPCNcrsFinal.push_back(PionTPCNcrs.at(i1)); + PionTPCNclsFinal.push_back(PionTPCNcls.at(i1)); + KaonTOFNsigmaFinal.push_back(KaonTOFNsigma.at(i2)); + KaonDcaxyFinal.push_back(KaonDcaxy.at(i2)); + KaonDcazFinal.push_back(KaonDcaz.at(i2)); + KaonTPCNcrsFinal.push_back(KaonTPCNcrs.at(i2)); + KaonTPCNclsFinal.push_back(KaonTPCNcls.at(i2)); + K0D1DcaxyFinal.push_back(K0D1Dcaxy.at(i3)); + K0D1TPCNcrsFinal.push_back(K0D1TPCNcrs.at(i3)); + K0D1TPCNclsFinal.push_back(K0D1TPCNcls.at(i3)); + K0D2DcaxyFinal.push_back(K0D2Dcaxy.at(i3)); + K0D2TPCNcrsFinal.push_back(K0D2TPCNcrs.at(i3)); + K0D2TPCNclsFinal.push_back(K0D2TPCNcls.at(i3)); + K0CpaFinal.push_back(K0Cpa.at(i3)); + K0radiusFinal.push_back(K0radius.at(i3)); + K0DcaBetweenDaughtersFinal.push_back(K0DcaBetweenDaughters.at(i3)); + K0DcaFinal.push_back(K0Dca.at(i3)); + K0LifeTimeFinal.push_back(K0LifeTime.at(i3)); + if (pairsign > 0) { qaRegistry.fill(HIST("hInvMassf1"), F1Vector.M(), F1Vector.Pt()); numberF1 = numberF1 + 1; @@ -848,13 +977,13 @@ struct f1protonreducedtable { F1d1dummy = f1resonanced1.at(i5); F1d2dummy = f1resonanced2.at(i5); F1d3dummy = f1resonanced3.at(i5); - f1track(indexEvent, f1signal.at(i5), F1VectorDummy.Px(), F1VectorDummy.Py(), F1VectorDummy.Pz(), F1d1dummy.Px(), F1d1dummy.Py(), F1d1dummy.Pz(), F1d2dummy.Px(), F1d2dummy.Py(), F1d2dummy.Pz(), F1d3dummy.Px(), F1d3dummy.Py(), F1d3dummy.Pz(), PionTOFHitFinal.at(i5), KaonTOFHitFinal.at(i5), PionTPCFinal.at(i5), KaonTPCFinal.at(i5), KaonTPCPionHypoFinal.at(i5), F1VectorDummy.M(), f1kaonkshortmass.at(i5), F1PionIndex.at(i5), F1KaonIndex.at(i5), F1KshortDaughterPositiveIndex.at(i5), F1KshortDaughterNegativeIndex.at(i5)); + f1track(indexEvent, f1signal.at(i5), F1VectorDummy.Px(), F1VectorDummy.Py(), F1VectorDummy.Pz(), F1d1dummy.Px(), F1d1dummy.Py(), F1d1dummy.Pz(), F1d2dummy.Px(), F1d2dummy.Py(), F1d2dummy.Pz(), F1d3dummy.Px(), F1d3dummy.Py(), F1d3dummy.Pz(), PionTOFHitFinal.at(i5), KaonTOFHitFinal.at(i5), PionTPCFinal.at(i5), KaonTPCFinal.at(i5), KaonTPCPionHypoFinal.at(i5), F1VectorDummy.M(), f1kaonkshortmass.at(i5), F1PionIndex.at(i5), F1KaonIndex.at(i5), F1KshortDaughterPositiveIndex.at(i5), F1KshortDaughterNegativeIndex.at(i5), PionTOFNsigmaFinal.at(i5), PionDcaxyFinal.at(i5), PionDcazFinal.at(i5), PionTPCNclsFinal.at(i5), PionTPCNcrsFinal.at(i5), KaonTOFNsigmaFinal.at(i5), KaonDcaxyFinal.at(i5), KaonDcazFinal.at(i5), KaonTPCNclsFinal.at(i5), KaonTPCNcrsFinal.at(i5), K0D1DcaxyFinal.at(i5), K0D1TPCNclsFinal.at(i5), K0D1TPCNcrsFinal.at(i5), K0D2DcaxyFinal.at(i5), K0D2TPCNclsFinal.at(i5), K0D2TPCNcrsFinal.at(i5), K0CpaFinal.at(i5), K0radiusFinal.at(i5), K0DcaBetweenDaughtersFinal.at(i5), K0DcaFinal.at(i5), K0LifeTimeFinal.at(i5)); } //// Fill track table for proton////////////////// for (auto iproton = protons.begin(); iproton != protons.end(); ++iproton) { auto i6 = std::distance(protons.begin(), iproton); ProtonVectorDummy2 = protons.at(i6); - protontrack(indexEvent, ProtonCharge.at(i6), ProtonVectorDummy2.Px(), ProtonVectorDummy2.Py(), ProtonVectorDummy2.Pz(), ProtonTPCNsigma.at(i6), ProtonTOFHit.at(i6), ProtonTOFNsigma.at(i6), ProtonIndex.at(i6)); + protontrack(indexEvent, ProtonCharge.at(i6), ProtonVectorDummy2.Px(), ProtonVectorDummy2.Py(), ProtonVectorDummy2.Pz(), ProtonTPCNsigma.at(i6), ProtonTOFHit.at(i6), ProtonTOFNsigma.at(i6), ProtonIndex.at(i6), ProtonDcaxy.at(i6), ProtonDcaz.at(i6), ProtonTPCNcls.at(i6), ProtonTPCNcrs.at(i6)); } } } diff --git a/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx b/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx index 2b4f6b1b9b2..fedf7f8d332 100644 --- a/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx +++ b/PWGLF/Tasks/Resonances/f1protoncorrelation.cxx @@ -84,7 +84,7 @@ struct f1protoncorrelation { // Event Mixing Configurable nEvtMixing{"nEvtMixing", 10, "Number of events to mix"}; Configurable nEvtMixingBkg{"nEvtMixingBkg", 5, "Number of events to mix for background reconstruction"}; - ConfigurableAxis CfgVtxBins{"CfgVtxBins", {10, -10, 10}, "Mixing bins - z-vertex"}; + ConfigurableAxis CfgVtxBins{"CfgVtxBins", {VARIABLE_WIDTH, 10, -10, 10}, "Mixing bins - z-vertex"}; ConfigurableAxis CfgMultBins{"CfgMultBins", {VARIABLE_WIDTH, 0.0, 40.0, 80.0, 500.0}, "Mixing bins - number of contributor"}; // THnsparse bining