From 96ff6af9835d5d7e3c313c1ff3122e53e762dfec Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Sun, 24 Mar 2024 10:29:23 +0100 Subject: [PATCH 1/6] PWGLF: Add Nsigma-TOF at analysis time: first test --- PWGLF/TableProducer/lambdakzeropid.cxx | 14 +- .../derivedlambdakzeroanalysis.cxx | 235 +++++++++++------- 2 files changed, 146 insertions(+), 103 deletions(-) diff --git a/PWGLF/TableProducer/lambdakzeropid.cxx b/PWGLF/TableProducer/lambdakzeropid.cxx index 0f1e68465f9..9865f0a8eaa 100644 --- a/PWGLF/TableProducer/lambdakzeropid.cxx +++ b/PWGLF/TableProducer/lambdakzeropid.cxx @@ -60,7 +60,7 @@ using std::array; // Cores with references and TOF pid using dauTracks = soa::Join; -using V0FullCores = soa::Join; +using V0FullCores = soa::Join; struct lambdakzeropid { // TOF pid for strangeness (recalculated with topology) @@ -418,12 +418,12 @@ struct lambdakzeropid { float deltaTimePositiveK0ShortPi = -1e+6; float deltaTimeNegativeK0ShortPi = -1e+6; - float nSigmaPositiveLambdaPi = -1e+6; - float nSigmaPositiveLambdaPr = -1e+6; - float nSigmaNegativeLambdaPi = -1e+6; - float nSigmaNegativeLambdaPr = -1e+6; - float nSigmaPositiveK0ShortPi = -1e+6; - float nSigmaNegativeK0ShortPi = -1e+6; + float nSigmaPositiveLambdaPi = -1e+3; + float nSigmaPositiveLambdaPr = -1e+3; + float nSigmaNegativeLambdaPi = -1e+3; + float nSigmaNegativeLambdaPr = -1e+3; + float nSigmaPositiveK0ShortPi = -1e+3; + float nSigmaNegativeK0ShortPi = -1e+3; float velocityPositivePr = velocity(posTrack.getP(), o2::constants::physics::MassProton); float velocityPositivePi = velocity(posTrack.getP(), o2::constants::physics::MassPionCharged); diff --git a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx index e3e2e0aef90..6bc201b5030 100644 --- a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx @@ -56,12 +56,12 @@ using namespace o2::framework::expressions; using std::array; using dauTracks = soa::Join; -using v0Candidates = soa::Join; -using v0MCCandidates = soa::Join; +using v0Candidates = soa::Join; +using v0MCCandidates = soa::Join; -// simple checkers -#define bitset(var, nbit) ((var) |= (1 << (nbit))) -#define bitcheck(var, nbit) ((var) & (1 << (nbit))) +// simple checkers, but ensure 64 bit integers +#define bitset(var, nbit) ((var) |= (static_cast(1) << static_cast(nbit))) +#define bitcheck(var, nbit) ((var) & (static_cast(1) << static_cast(nbit))) struct derivedlambdakzeroanalysis { HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -95,8 +95,11 @@ struct derivedlambdakzeroanalysis { Configurable requirePosITSonly{"requirePosITSonly", false, "require that positive track is ITSonly (overrides TPC quality)"}; Configurable requireNegITSonly{"requireNegITSonly", false, "require that negative track is ITSonly (overrides TPC quality)"}; - // PID (TPC) + // PID (TPC/TOF) Configurable TpcPidNsigmaCut{"TpcPidNsigmaCut", 5, "TpcPidNsigmaCut"}; + Configurable TofPidNsigmaCutLaPr{"TofPidNsigmaCutLaPr", 1e+6, "TofPidNsigmaCutLaPr"}; + Configurable TofPidNsigmaCutLaPi{"TofPidNsigmaCutLaPi", 1e+6, "TofPidNsigmaCutLaPi"}; + Configurable TofPidNsigmaCutK0Pi{"TofPidNsigmaCutK0Pi", 1e+6, "TofPidNsigmaCutK0Pi"}; Configurable doCompleteQA{"doCompleteQA", false, "do topological variable QA histograms"}; Configurable doTPCQA{"doTPCQA", false, "do TPC QA histograms"}; @@ -147,98 +150,122 @@ struct derivedlambdakzeroanalysis { // MC coll assoc QA axis ConfigurableAxis axisMonteCarloNch{"axisMonteCarloNch", {300, 0.0f, 3000.0f}, "N_{ch} MC"}; - enum selection { selCosPA = 0, - selRadius, - selRadiusMax, - selDCANegToPV, - selDCAPosToPV, - selDCAV0Dau, - selK0ShortRapidity, - selLambdaRapidity, - selTPCPIDPositivePion, - selTPCPIDNegativePion, - selTPCPIDPositiveProton, - selTPCPIDNegativeProton, - selTOFDeltaTPositiveProtonLambda, - selTOFDeltaTPositivePionLambda, - selTOFDeltaTPositivePionK0Short, - selTOFDeltaTNegativeProtonLambda, - selTOFDeltaTNegativePionLambda, - selTOFDeltaTNegativePionK0Short, - selK0ShortCTau, - selLambdaCTau, - selK0ShortArmenteros, - selPosGoodTPCTrack, - selNegGoodTPCTrack, - selPosItsOnly, - selNegItsOnly, - selConsiderK0Short, // for mc tagging - selConsiderLambda, // for mc tagging - selConsiderAntiLambda, // for mc tagging - selPhysPrimK0Short, // for mc tagging - selPhysPrimLambda, // for mc tagging - selPhysPrimAntiLambda // for mc tagging + enum selection : uint64_t { selCosPA = 0, + selRadius, + selRadiusMax, + selDCANegToPV, + selDCAPosToPV, + selDCAV0Dau, + selK0ShortRapidity, + selLambdaRapidity, + selTPCPIDPositivePion, + selTPCPIDNegativePion, + selTPCPIDPositiveProton, + selTPCPIDNegativeProton, + selTOFDeltaTPositiveProtonLambda, + selTOFDeltaTPositivePionLambda, + selTOFDeltaTPositivePionK0Short, + selTOFDeltaTNegativeProtonLambda, + selTOFDeltaTNegativePionLambda, + selTOFDeltaTNegativePionK0Short, + selTOFNSigmaPositiveProtonLambda, // Nsigma + selTOFNSigmaPositivePionLambda, // Nsigma + selTOFNSigmaPositivePionK0Short, // Nsigma + selTOFNSigmaNegativeProtonLambda, // Nsigma + selTOFNSigmaNegativePionLambda, // Nsigma + selTOFNSigmaNegativePionK0Short, // Nsigma + selK0ShortCTau, + selLambdaCTau, + selK0ShortArmenteros, + selPosGoodTPCTrack, + selNegGoodTPCTrack, + selPosItsOnly, + selNegItsOnly, + selConsiderK0Short, // for mc tagging + selConsiderLambda, // for mc tagging + selConsiderAntiLambda, // for mc tagging + selPhysPrimK0Short, // for mc tagging + selPhysPrimLambda, // for mc tagging + selPhysPrimAntiLambda, // for mc tagging }; - uint32_t maskTopological; - uint32_t maskTopoNoV0Radius; - uint32_t maskTopoNoDCANegToPV; - uint32_t maskTopoNoDCAPosToPV; - uint32_t maskTopoNoCosPA; - uint32_t maskTopoNoDCAV0Dau; - uint32_t maskTrackProperties; + uint64_t maskTopological; + uint64_t maskTopoNoV0Radius; + uint64_t maskTopoNoDCANegToPV; + uint64_t maskTopoNoDCAPosToPV; + uint64_t maskTopoNoCosPA; + uint64_t maskTopoNoDCAV0Dau; + uint64_t maskTrackProperties; - uint32_t maskK0ShortSpecific; - uint32_t maskLambdaSpecific; - uint32_t maskAntiLambdaSpecific; + uint64_t maskK0ShortSpecific; + uint64_t maskLambdaSpecific; + uint64_t maskAntiLambdaSpecific; - uint32_t maskSelectionK0Short; - uint32_t maskSelectionLambda; - uint32_t maskSelectionAntiLambda; + uint64_t maskSelectionK0Short; + uint64_t maskSelectionLambda; + uint64_t maskSelectionAntiLambda; - uint32_t secondaryMaskSelectionLambda; - uint32_t secondaryMaskSelectionAntiLambda; + uint64_t secondaryMaskSelectionLambda; + uint64_t secondaryMaskSelectionAntiLambda; void init(InitContext const&) { // initialise bit masks - maskTopological = (1 << selCosPA) | (1 << selRadius) | (1 << selDCANegToPV) | (1 << selDCAPosToPV) | (1 << selDCAV0Dau) | (1 << selRadiusMax); - maskTopoNoV0Radius = (1 << selCosPA) | (1 << selDCANegToPV) | (1 << selDCAPosToPV) | (1 << selDCAV0Dau) | (1 << selRadiusMax); - maskTopoNoDCANegToPV = (1 << selCosPA) | (1 << selRadius) | (1 << selDCAPosToPV) | (1 << selDCAV0Dau) | (1 << selRadiusMax); - maskTopoNoDCAPosToPV = (1 << selCosPA) | (1 << selRadius) | (1 << selDCANegToPV) | (1 << selDCAV0Dau) | (1 << selRadiusMax); - maskTopoNoCosPA = (1 << selRadius) | (1 << selDCANegToPV) | (1 << selDCAPosToPV) | (1 << selDCAV0Dau) | (1 << selRadiusMax); - maskTopoNoDCAV0Dau = (1 << selCosPA) | (1 << selRadius) | (1 << selDCANegToPV) | (1 << selDCAPosToPV) | (1 << selRadiusMax); + maskTopological = (uint64_t(1) << selCosPA) | (uint64_t(1) << selRadius) | (uint64_t(1) << selDCANegToPV) | (uint64_t(1) << selDCAPosToPV) | (uint64_t(1) << selDCAV0Dau) | (uint64_t(1) << selRadiusMax); + maskTopoNoV0Radius = (uint64_t(1) << selCosPA) | (uint64_t(1) << selDCANegToPV) | (uint64_t(1) << selDCAPosToPV) | (uint64_t(1) << selDCAV0Dau) | (uint64_t(1) << selRadiusMax); + maskTopoNoDCANegToPV = (uint64_t(1) << selCosPA) | (uint64_t(1) << selRadius) | (uint64_t(1) << selDCAPosToPV) | (uint64_t(1) << selDCAV0Dau) | (uint64_t(1) << selRadiusMax); + maskTopoNoDCAPosToPV = (uint64_t(1) << selCosPA) | (uint64_t(1) << selRadius) | (uint64_t(1) << selDCANegToPV) | (uint64_t(1) << selDCAV0Dau) | (uint64_t(1) << selRadiusMax); + maskTopoNoCosPA = (uint64_t(1) << selRadius) | (uint64_t(1) << selDCANegToPV) | (uint64_t(1) << selDCAPosToPV) | (uint64_t(1) << selDCAV0Dau) | (uint64_t(1) << selRadiusMax); + maskTopoNoDCAV0Dau = (uint64_t(1) << selCosPA) | (uint64_t(1) << selRadius) | (uint64_t(1) << selDCANegToPV) | (uint64_t(1) << selDCAPosToPV) | (uint64_t(1) << selRadiusMax); - maskK0ShortSpecific = (1 << selK0ShortRapidity) | (1 << selK0ShortCTau) | (1 << selK0ShortArmenteros) | (1 << selConsiderK0Short); - maskLambdaSpecific = (1 << selLambdaRapidity) | (1 << selLambdaCTau) | (1 << selConsiderLambda); - maskAntiLambdaSpecific = (1 << selLambdaRapidity) | (1 << selLambdaCTau) | (1 << selConsiderAntiLambda); + maskK0ShortSpecific = (uint64_t(1) << selK0ShortRapidity) | (uint64_t(1) << selK0ShortCTau) | (uint64_t(1) << selK0ShortArmenteros) | (uint64_t(1) << selConsiderK0Short); + maskLambdaSpecific = (uint64_t(1) << selLambdaRapidity) | (uint64_t(1) << selLambdaCTau) | (uint64_t(1) << selConsiderLambda); + maskAntiLambdaSpecific = (uint64_t(1) << selLambdaRapidity) | (uint64_t(1) << selLambdaCTau) | (uint64_t(1) << selConsiderAntiLambda); // ask for specific TPC PID selections maskTrackProperties = 0; if (requirePosITSonly) { - maskTrackProperties = maskTrackProperties | (1 << selPosItsOnly); + maskTrackProperties = maskTrackProperties | (uint64_t(1) << selPosItsOnly); } else { - maskTrackProperties = maskTrackProperties | (1 << selPosGoodTPCTrack); + maskTrackProperties = maskTrackProperties | (uint64_t(1) << selPosGoodTPCTrack); // TPC signal is available: ask for positive track PID - maskK0ShortSpecific = maskK0ShortSpecific | (1 << selTPCPIDPositivePion) | (1 << selTOFDeltaTPositivePionK0Short); - maskLambdaSpecific = maskLambdaSpecific | (1 << selTPCPIDPositiveProton) | (1 << selTOFDeltaTPositiveProtonLambda); - maskAntiLambdaSpecific = maskAntiLambdaSpecific | (1 << selTPCPIDPositivePion) | (1 << selTOFDeltaTPositivePionLambda); + if(TpcPidNsigmaCut<1e+5){ // safeguard for no cut + maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTPCPIDPositivePion); + maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTPCPIDPositiveProton); + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTPCPIDPositivePion); + } + + if(TofPidNsigmaCutK0Pi<1e+5) // safeguard for no cut + maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTOFNSigmaPositivePionK0Short) | (uint64_t(1) << selTOFDeltaTPositivePionK0Short); + if(TofPidNsigmaCutLaPr<1e+5) // safeguard for no cut + maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTOFNSigmaPositiveProtonLambda) | (uint64_t(1) << selTOFDeltaTPositiveProtonLambda); + if(TofPidNsigmaCutLaPi<1e+5) // safeguard for no cut + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTOFNSigmaPositivePionLambda) | (uint64_t(1) << selTOFDeltaTPositivePionLambda); } if (requireNegITSonly) { - maskTrackProperties = maskTrackProperties | (1 << selNegItsOnly); + maskTrackProperties = maskTrackProperties | (uint64_t(1) << selNegItsOnly); } else { - maskTrackProperties = maskTrackProperties | (1 << selNegGoodTPCTrack); + maskTrackProperties = maskTrackProperties | (uint64_t(1) << selNegGoodTPCTrack); // TPC signal is available: ask for negative track PID - maskK0ShortSpecific = maskK0ShortSpecific | (1 << selTPCPIDNegativePion) | (1 << selTOFDeltaTNegativePionK0Short); - maskLambdaSpecific = maskLambdaSpecific | (1 << selTPCPIDNegativePion) | (1 << selTOFDeltaTNegativePionLambda); - maskAntiLambdaSpecific = maskAntiLambdaSpecific | (1 << selTPCPIDNegativeProton) | (1 << selTOFDeltaTNegativeProtonLambda); + if(TpcPidNsigmaCut<1e+5){ // safeguard for no cut + maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTPCPIDNegativePion); + maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTPCPIDNegativePion); + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTPCPIDNegativeProton); + } + + if(TofPidNsigmaCutK0Pi<1e+5) // safeguard for no cut + maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTOFNSigmaNegativePionK0Short) | (uint64_t(1) << selTOFDeltaTNegativePionK0Short); + if(TofPidNsigmaCutLaPr<1e+5) // safeguard for no cut + maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTOFNSigmaNegativePionLambda) | (uint64_t(1) << selTOFDeltaTNegativePionLambda); + if(TofPidNsigmaCutLaPi<1e+5) // safeguard for no cut + maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTOFNSigmaNegativeProtonLambda) | (uint64_t(1) << selTOFDeltaTNegativeProtonLambda); } // Primary particle selection, central to analysis - maskSelectionK0Short = maskTopological | maskTrackProperties | maskK0ShortSpecific | (1 << selPhysPrimK0Short); - maskSelectionLambda = maskTopological | maskTrackProperties | maskLambdaSpecific | (1 << selPhysPrimLambda); - maskSelectionAntiLambda = maskTopological | maskTrackProperties | maskAntiLambdaSpecific | (1 << selPhysPrimAntiLambda); + maskSelectionK0Short = maskTopological | maskTrackProperties | maskK0ShortSpecific | (uint64_t(1) << selPhysPrimK0Short); + maskSelectionLambda = maskTopological | maskTrackProperties | maskLambdaSpecific | (uint64_t(1) << selPhysPrimLambda); + maskSelectionAntiLambda = maskTopological | maskTrackProperties | maskAntiLambdaSpecific | (uint64_t(1) << selPhysPrimAntiLambda); // No primary requirement for feeddown matrix secondaryMaskSelectionLambda = maskTopological | maskTrackProperties | maskLambdaSpecific; @@ -439,10 +466,10 @@ struct derivedlambdakzeroanalysis { } template - uint32_t computeReconstructionBitmap(TV0 v0, TCollision collision) + uint64_t computeReconstructionBitmap(TV0 v0, TCollision collision) // precalculate this information so that a check is one mask operation, not many { - uint32_t bitMap = 0; + uint64_t bitMap = 0; // Base topological variables if (v0.v0radius() > v0radius) bitset(bitMap, selRadius); @@ -482,7 +509,7 @@ struct derivedlambdakzeroanalysis { if (fabs(negTrackExtra.tpcNSigmaPr()) < TpcPidNsigmaCut) bitset(bitMap, selTPCPIDNegativeProton); - // TOF PID + // TOF PID in DeltaT // Positive track if (fabs(v0.posTOFDeltaTLaPr()) < maxDeltaTimeProton) bitset(bitMap, selTOFDeltaTPositiveProtonLambda); @@ -498,6 +525,22 @@ struct derivedlambdakzeroanalysis { if (fabs(v0.negTOFDeltaTK0Pi()) < maxDeltaTimePion) bitset(bitMap, selTOFDeltaTNegativePionK0Short); + // TOF PID in NSigma + // Positive track + if (fabs(v0.posTOFNSigmaLaPr()) < TofPidNsigmaCutLaPr) + bitset(bitMap, selTOFNSigmaPositiveProtonLambda); + if (fabs(v0.posTOFNSigmaLaPi()) < TofPidNsigmaCutLaPi) + bitset(bitMap, selTOFNSigmaPositivePionLambda); + if (fabs(v0.posTOFNSigmaK0Pi()) < TofPidNsigmaCutK0Pi) + bitset(bitMap, selTOFNSigmaPositivePionK0Short); + // Negative track + if (fabs(v0.negTOFNSigmaLaPr()) < TofPidNsigmaCutLaPr) + bitset(bitMap, selTOFNSigmaNegativeProtonLambda); + if (fabs(v0.negTOFNSigmaLaPi()) < TofPidNsigmaCutLaPi) + bitset(bitMap, selTOFNSigmaNegativePionLambda); + if (fabs(v0.negTOFNSigmaK0Pi()) < TofPidNsigmaCutK0Pi) + bitset(bitMap, selTOFNSigmaNegativePionK0Short); + // ITS only tag if (posTrackExtra.tpcCrossedRows() < 1) bitset(bitMap, selPosItsOnly); @@ -518,10 +561,10 @@ struct derivedlambdakzeroanalysis { } template - uint32_t computeMCAssociation(TV0 v0) + uint64_t computeMCAssociation(TV0 v0) // precalculate this information so that a check is one mask operation, not many { - uint32_t bitMap = 0; + uint64_t bitMap = 0; // check for specific particle species if (v0.pdgCode() == 310 && v0.pdgCodePositive() == 211 && v0.pdgCodeNegative() == -211) { @@ -542,13 +585,13 @@ struct derivedlambdakzeroanalysis { return bitMap; } - bool verifyMask(uint32_t bitmap, uint32_t mask) + bool verifyMask(uint64_t bitmap, uint64_t mask) { return (bitmap & mask) == mask; } template - void analyseCandidate(TV0 v0, float centrality, uint32_t selMap) + void analyseCandidate(TV0 v0, float centrality, uint64_t selMap) // precalculate this information so that a check is one mask operation, not many { auto posTrackExtra = v0.template posTrackExtra_as(); @@ -729,7 +772,7 @@ struct derivedlambdakzeroanalysis { } template - void analyseCollisionAssociation(TV0 v0, int mcNch, bool correctAssociation, uint32_t selMap) + void analyseCollisionAssociation(TV0 v0, int mcNch, bool correctAssociation, uint64_t selMap) // analyse collision association { // __________________________________________ @@ -752,7 +795,7 @@ struct derivedlambdakzeroanalysis { } template - void fillFeeddownMatrix(TV0 v0, float centrality, uint32_t selMap) + void fillFeeddownMatrix(TV0 v0, float centrality, uint64_t selMap) // fill feeddown matrix for Lambdas or AntiLambdas // fixme: a potential improvement would be to consider mass windows for the l/al { @@ -819,11 +862,11 @@ struct derivedlambdakzeroanalysis { // fill AP plot for all V0s histos.fill(HIST("GeneralQA/h2dArmenterosAll"), v0.alpha(), v0.qtarm()); - uint32_t selMap = computeReconstructionBitmap(v0, collision); + uint64_t selMap = computeReconstructionBitmap(v0, collision); // consider for histograms for all species - selMap = selMap | (1 << selConsiderK0Short) | (1 << selConsiderLambda) | (1 << selConsiderAntiLambda); - selMap = selMap | (1 << selPhysPrimK0Short) | (1 << selPhysPrimLambda) | (1 << selPhysPrimAntiLambda); + selMap = selMap | (uint64_t(1) << selConsiderK0Short) | (uint64_t(1) << selConsiderLambda) | (uint64_t(1) << selConsiderAntiLambda); + selMap = selMap | (uint64_t(1) << selPhysPrimK0Short) | (uint64_t(1) << selPhysPrimLambda) | (uint64_t(1) << selPhysPrimAntiLambda); analyseCandidate(v0, centrality, selMap); } // end v0 loop @@ -873,7 +916,7 @@ struct derivedlambdakzeroanalysis { // fill AP plot for all V0s histos.fill(HIST("GeneralQA/h2dArmenterosAll"), v0.alpha(), v0.qtarm()); - uint32_t selMap = computeReconstructionBitmap(v0, collision); + uint64_t selMap = computeReconstructionBitmap(v0, collision); selMap = selMap | computeMCAssociation(v0); // feeddown matrix always with association @@ -882,8 +925,8 @@ struct derivedlambdakzeroanalysis { // consider only associated candidates if asked to do so, disregard association if (!doMCAssociation) { - selMap = selMap | (1 << selConsiderK0Short) | (1 << selConsiderLambda) | (1 << selConsiderAntiLambda); - selMap = selMap | (1 << selPhysPrimK0Short) | (1 << selPhysPrimLambda) | (1 << selPhysPrimAntiLambda); + selMap = selMap | (uint64_t(1) << selConsiderK0Short) | (uint64_t(1) << selConsiderLambda) | (uint64_t(1) << selConsiderAntiLambda); + selMap = selMap | (uint64_t(1) << selPhysPrimK0Short) | (uint64_t(1) << selPhysPrimLambda) | (uint64_t(1) << selPhysPrimAntiLambda); } analyseCandidate(v0, centrality, selMap); @@ -920,49 +963,49 @@ struct derivedlambdakzeroanalysis { for (auto& gVec : geK0Short) { if (gVec.generatedK0Short().size() != hK0Short->GetNcells()) LOGF(fatal, "K0Short: Number of elements in generated array and number of cells in receiving histogram differ: %i vs %i!", gVec.generatedK0Short().size(), hK0Short->GetNcells()); - for (uint32_t iv = 0; iv < hK0Short->GetNcells(); iv++) { + for (uint64_t iv = 0; iv < hK0Short->GetNcells(); iv++) { hK0Short->SetBinContent(iv, hK0Short->GetBinContent(iv) + gVec.generatedK0Short()[iv]); } } for (auto& gVec : geLambda) { if (gVec.generatedLambda().size() != hLambda->GetNcells()) LOGF(fatal, "Lambda: Number of elements in generated array and number of cells in receiving histogram differ: %i vs %i!", gVec.generatedLambda().size(), hLambda->GetNcells()); - for (uint32_t iv = 0; iv < hLambda->GetNcells(); iv++) { + for (uint64_t iv = 0; iv < hLambda->GetNcells(); iv++) { hLambda->SetBinContent(iv, hLambda->GetBinContent(iv) + gVec.generatedLambda()[iv]); } } for (auto& gVec : geAntiLambda) { if (gVec.generatedAntiLambda().size() != hAntiLambda->GetNcells()) LOGF(fatal, "AntiLambda: Number of elements in generated array and number of cells in receiving histogram differ: %i vs %i!", gVec.generatedAntiLambda().size(), hAntiLambda->GetNcells()); - for (uint32_t iv = 0; iv < hAntiLambda->GetNcells(); iv++) { + for (uint64_t iv = 0; iv < hAntiLambda->GetNcells(); iv++) { hAntiLambda->SetBinContent(iv, hAntiLambda->GetBinContent(iv) + gVec.generatedAntiLambda()[iv]); } } for (auto& gVec : geXiMinus) { if (gVec.generatedXiMinus().size() != hXiMinus->GetNcells()) LOGF(fatal, "XiMinus: Number of elements in generated array and number of cells in receiving histogram differ: %i vs %i!", gVec.generatedXiMinus().size(), hXiMinus->GetNcells()); - for (uint32_t iv = 0; iv < hXiMinus->GetNcells(); iv++) { + for (uint64_t iv = 0; iv < hXiMinus->GetNcells(); iv++) { hXiMinus->SetBinContent(iv, hXiMinus->GetBinContent(iv) + gVec.generatedXiMinus()[iv]); } } for (auto& gVec : geXiPlus) { if (gVec.generatedXiPlus().size() != hXiPlus->GetNcells()) LOGF(fatal, "XiPlus: Number of elements in generated array and number of cells in receiving histogram differ: %i vs %i!", gVec.generatedXiPlus().size(), hXiPlus->GetNcells()); - for (uint32_t iv = 0; iv < hXiPlus->GetNcells(); iv++) { + for (uint64_t iv = 0; iv < hXiPlus->GetNcells(); iv++) { hXiPlus->SetBinContent(iv, hXiPlus->GetBinContent(iv) + gVec.generatedXiPlus()[iv]); } } for (auto& gVec : geOmegaMinus) { if (gVec.generatedOmegaMinus().size() != hOmegaMinus->GetNcells()) LOGF(fatal, "OmegaMinus: Number of elements in generated array and number of cells in receiving histogram differ: %i vs %i!", gVec.generatedOmegaMinus().size(), hOmegaMinus->GetNcells()); - for (uint32_t iv = 0; iv < hOmegaMinus->GetNcells(); iv++) { + for (uint64_t iv = 0; iv < hOmegaMinus->GetNcells(); iv++) { hOmegaMinus->SetBinContent(iv, hOmegaMinus->GetBinContent(iv) + gVec.generatedOmegaMinus()[iv]); } } for (auto& gVec : geOmegaPlus) { if (gVec.generatedOmegaPlus().size() != hOmegaPlus->GetNcells()) LOGF(fatal, "OmegaPlus: Number of elements in generated array and number of cells in receiving histogram differ: %i vs %i!", gVec.generatedOmegaPlus().size(), hOmegaPlus->GetNcells()); - for (uint32_t iv = 0; iv < hOmegaPlus->GetNcells(); iv++) { + for (uint64_t iv = 0; iv < hOmegaPlus->GetNcells(); iv++) { hOmegaPlus->SetBinContent(iv, hOmegaPlus->GetBinContent(iv) + gVec.generatedOmegaPlus()[iv]); } } From e1a5e27dd23ecb98a34753828b3acd816fe81e16 Mon Sep 17 00:00:00 2001 From: ALICE Builder Date: Sun, 24 Mar 2024 10:30:46 +0100 Subject: [PATCH 2/6] Please consider the following formatting changes (#265) --- .../Strangeness/derivedlambdakzeroanalysis.cxx | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx index 6bc201b5030..37822cbee97 100644 --- a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx @@ -230,17 +230,17 @@ struct derivedlambdakzeroanalysis { } else { maskTrackProperties = maskTrackProperties | (uint64_t(1) << selPosGoodTPCTrack); // TPC signal is available: ask for positive track PID - if(TpcPidNsigmaCut<1e+5){ // safeguard for no cut + if (TpcPidNsigmaCut < 1e+5) { // safeguard for no cut maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTPCPIDPositivePion); maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTPCPIDPositiveProton); maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTPCPIDPositivePion); } - if(TofPidNsigmaCutK0Pi<1e+5) // safeguard for no cut + if (TofPidNsigmaCutK0Pi < 1e+5) // safeguard for no cut maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTOFNSigmaPositivePionK0Short) | (uint64_t(1) << selTOFDeltaTPositivePionK0Short); - if(TofPidNsigmaCutLaPr<1e+5) // safeguard for no cut + if (TofPidNsigmaCutLaPr < 1e+5) // safeguard for no cut maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTOFNSigmaPositiveProtonLambda) | (uint64_t(1) << selTOFDeltaTPositiveProtonLambda); - if(TofPidNsigmaCutLaPi<1e+5) // safeguard for no cut + if (TofPidNsigmaCutLaPi < 1e+5) // safeguard for no cut maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTOFNSigmaPositivePionLambda) | (uint64_t(1) << selTOFDeltaTPositivePionLambda); } if (requireNegITSonly) { @@ -248,17 +248,17 @@ struct derivedlambdakzeroanalysis { } else { maskTrackProperties = maskTrackProperties | (uint64_t(1) << selNegGoodTPCTrack); // TPC signal is available: ask for negative track PID - if(TpcPidNsigmaCut<1e+5){ // safeguard for no cut + if (TpcPidNsigmaCut < 1e+5) { // safeguard for no cut maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTPCPIDNegativePion); maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTPCPIDNegativePion); maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTPCPIDNegativeProton); } - if(TofPidNsigmaCutK0Pi<1e+5) // safeguard for no cut + if (TofPidNsigmaCutK0Pi < 1e+5) // safeguard for no cut maskK0ShortSpecific = maskK0ShortSpecific | (uint64_t(1) << selTOFNSigmaNegativePionK0Short) | (uint64_t(1) << selTOFDeltaTNegativePionK0Short); - if(TofPidNsigmaCutLaPr<1e+5) // safeguard for no cut + if (TofPidNsigmaCutLaPr < 1e+5) // safeguard for no cut maskLambdaSpecific = maskLambdaSpecific | (uint64_t(1) << selTOFNSigmaNegativePionLambda) | (uint64_t(1) << selTOFDeltaTNegativePionLambda); - if(TofPidNsigmaCutLaPi<1e+5) // safeguard for no cut + if (TofPidNsigmaCutLaPi < 1e+5) // safeguard for no cut maskAntiLambdaSpecific = maskAntiLambdaSpecific | (uint64_t(1) << selTOFNSigmaNegativeProtonLambda) | (uint64_t(1) << selTOFDeltaTNegativeProtonLambda); } From 7d8a2ba15280ffe491bcdfdc105e20336ef9e06c Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Sun, 24 Mar 2024 19:06:43 +0100 Subject: [PATCH 3/6] Modifications for further exploratory studies --- PWGLF/DataModel/LFStrangenessTables.h | 2 +- PWGLF/TableProducer/lambdakzeromcfinder.cxx | 6 ++--- .../derivedlambdakzeroanalysis.cxx | 27 +++++++++++++++++++ 3 files changed, 31 insertions(+), 4 deletions(-) diff --git a/PWGLF/DataModel/LFStrangenessTables.h b/PWGLF/DataModel/LFStrangenessTables.h index ec414b89522..2cf4e1df5bc 100755 --- a/PWGLF/DataModel/LFStrangenessTables.h +++ b/PWGLF/DataModel/LFStrangenessTables.h @@ -88,7 +88,7 @@ namespace dautrack { //______________________________________________________ // Daughter track declarations for derived data analysis -DECLARE_SOA_COLUMN(DetectorMap, detectorMap, uint8_t); //! detector map for reference +DECLARE_SOA_COLUMN(DetectorMap, detectorMap, uint8_t); //! detector map for reference (see DetectorMapEnum) DECLARE_SOA_COLUMN(ITSClusterSizes, itsClusterSizes, uint32_t); //! ITS cluster sizes per layer DECLARE_SOA_COLUMN(TPCClusters, tpcClusters, uint8_t); //! N TPC clusters DECLARE_SOA_COLUMN(TPCCrossedRows, tpcCrossedRows, uint8_t); //! N TPC clusters diff --git a/PWGLF/TableProducer/lambdakzeromcfinder.cxx b/PWGLF/TableProducer/lambdakzeromcfinder.cxx index 12da54eed8d..2ba57c5416e 100644 --- a/PWGLF/TableProducer/lambdakzeromcfinder.cxx +++ b/PWGLF/TableProducer/lambdakzeromcfinder.cxx @@ -66,7 +66,7 @@ using namespace ROOT::Math; using LabeledTracks = soa::Join; struct lambdakzeromcfinder { - Produces v0; + Produces v0; Produces fullv0labels; HistogramRegistry histos{"Histos", {}, OutputObjHandlingPolicy::AnalysisObject}; @@ -404,7 +404,7 @@ struct lambdakzeromcfinder { // V0 list established, populate for (auto ic : sortedIndices) { if (v0collisionId[ic] >= 0 || doUnassociatedV0s) { - v0(v0collisionId[ic], v0positiveIndex[ic], v0negativeIndex[ic]); + v0(v0collisionId[ic], v0positiveIndex[ic], v0negativeIndex[ic], 1); // type 1 : standard fullv0labels(v0mcLabel[ic]); } } @@ -476,7 +476,7 @@ struct lambdakzeromcfinder { // V0 list established, populate for (auto ic : sortedIndices) { if (v0collisionId[ic] >= 0 || doUnassociatedV0s) { - v0(v0collisionId[ic], v0positiveIndex[ic], v0negativeIndex[ic]); + v0(v0collisionId[ic], v0positiveIndex[ic], v0negativeIndex[ic], 1); fullv0labels(v0mcLabel[ic]); } } diff --git a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx index 37822cbee97..b70c9ec6af5 100644 --- a/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx +++ b/PWGLF/Tasks/Strangeness/derivedlambdakzeroanalysis.cxx @@ -104,6 +104,7 @@ struct derivedlambdakzeroanalysis { Configurable doCompleteQA{"doCompleteQA", false, "do topological variable QA histograms"}; Configurable doTPCQA{"doTPCQA", false, "do TPC QA histograms"}; Configurable doTOFQA{"doTOFQA", false, "do TOF QA histograms"}; + Configurable doIDetectPropQA{"doIDetectPropQA", false, "do Detector/ITS map QA"}; Configurable doPlainQA{"doPlainQA", true, "do simple 1D QA of candidates"}; Configurable qaMinPt{"qaMinPt", 0.0f, "minimum pT for QA plots"}; @@ -146,6 +147,8 @@ struct derivedlambdakzeroanalysis { // Track quality axes ConfigurableAxis axisTPCrows{"axisTPCrows", {160, 0.0f, 160.0f}, "N TPC rows"}; ConfigurableAxis axisITSclus{"axisITSclus", {7, 0.0f, 7.0f}, "N ITS Clusters"}; + ConfigurableAxis axisITScluMap{"axisITSMap", {128, -0.5f, 127.5f}, "ITS Cluster map"}; + ConfigurableAxis axisDetMap{"axisDetMap", {16, -0.5f, 15.5f}, "Detector use map"}; // MC coll assoc QA axis ConfigurableAxis axisMonteCarloNch{"axisMonteCarloNch", {300, 0.0f, 3000.0f}, "N_{ch} MC"}; @@ -420,6 +423,10 @@ struct derivedlambdakzeroanalysis { histos.add("K0Short/h2dPtVsNch", "h2dPtVsNch", kTH2F, {axisMonteCarloNch, axisPt}); histos.add("K0Short/h2dPtVsNch_BadCollAssig", "h2dPtVsNch_BadCollAssig", kTH2F, {axisMonteCarloNch, axisPt}); } + if (doIDetectPropQA) { + histos.add("K0Short/h4dPosDetectPropVsCentrality", "h4dPosDetectPropVsCentrality", kTHnF, {axisCentrality, axisDetMap, axisITScluMap, axisPtCoarse}); + histos.add("K0Short/h4dNegDetectPropVsCentrality", "h4dNegDetectPropVsCentrality", kTHnF, {axisCentrality, axisDetMap, axisITScluMap, axisPtCoarse}); + } } if (analyseLambda) { histos.add("Lambda/hPosDCAToPV", "hPosDCAToPV", kTH1F, {axisDCAtoPV}); @@ -433,6 +440,10 @@ struct derivedlambdakzeroanalysis { histos.add("Lambda/h2dPtVsNch", "h2dPtVsNch", kTH2F, {axisMonteCarloNch, axisPt}); histos.add("Lambda/h2dPtVsNch_BadCollAssig", "h2dPtVsNch_BadCollAssig", kTH2F, {axisMonteCarloNch, axisPt}); } + if (doIDetectPropQA) { + histos.add("Lambda/h4dPosDetectPropVsCentrality", "h4dPosDetectPropVsCentrality", kTHnF, {axisCentrality, axisDetMap, axisITScluMap, axisPtCoarse}); + histos.add("Lambda/h4dNegDetectPropVsCentrality", "h4dNegDetectPropVsCentrality", kTHnF, {axisCentrality, axisDetMap, axisITScluMap, axisPtCoarse}); + } } if (analyseAntiLambda) { histos.add("AntiLambda/hPosDCAToPV", "hPosDCAToPV", kTH1F, {axisDCAtoPV}); @@ -446,6 +457,10 @@ struct derivedlambdakzeroanalysis { histos.add("AntiLambda/h2dPtVsNch", "h2dPtVsNch", kTH2F, {axisMonteCarloNch, axisPt}); histos.add("AntiLambda/h2dPtVsNch_BadCollAssig", "h2dPtVsNch_BadCollAssig", kTH2F, {axisMonteCarloNch, axisPt}); } + if (doIDetectPropQA) { + histos.add("AntiLambda/h4dPosDetectPropVsCentrality", "h4dPosDetectPropVsCentrality", kTHnF, {axisCentrality, axisDetMap, axisITScluMap, axisPtCoarse}); + histos.add("AntiLambda/h4dNegDetectPropVsCentrality", "h4dNegDetectPropVsCentrality", kTHnF, {axisCentrality, axisDetMap, axisITScluMap, axisPtCoarse}); + } } } @@ -690,6 +705,10 @@ struct derivedlambdakzeroanalysis { histos.fill(HIST("K0Short/h3dNegTOFdeltaTvsTrackPt"), centrality, v0.negativept(), v0.negTOFDeltaTK0Pi()); } } + if (doIDetectPropQA) { + histos.fill(HIST("K0Short/h4dPosDetectPropVsCentrality"), centrality, posTrackExtra.detectorMap(), posTrackExtra.itsClusterMap(), v0.pt()); + histos.fill(HIST("K0Short/h4dNegDetectPropVsCentrality"), centrality, negTrackExtra.detectorMap(), negTrackExtra.itsClusterMap(), v0.pt()); + } } if (analyseLambda) { @@ -729,6 +748,10 @@ struct derivedlambdakzeroanalysis { histos.fill(HIST("Lambda/h3dNegTOFdeltaTvsTrackPt"), centrality, v0.negativept(), v0.negTOFDeltaTLaPi()); } } + if (doIDetectPropQA) { + histos.fill(HIST("Lambda/h4dPosDetectPropVsCentrality"), centrality, posTrackExtra.detectorMap(), posTrackExtra.itsClusterMap(), v0.pt()); + histos.fill(HIST("Lambda/h4dNegDetectPropVsCentrality"), centrality, negTrackExtra.detectorMap(), negTrackExtra.itsClusterMap(), v0.pt()); + } } if (analyseAntiLambda) { if (verifyMask(selMap, maskTopoNoV0Radius | maskAntiLambdaSpecific)) @@ -767,6 +790,10 @@ struct derivedlambdakzeroanalysis { histos.fill(HIST("AntiLambda/h3dNegTOFdeltaTvsTrackPt"), centrality, v0.negativept(), v0.negTOFDeltaTLaPr()); } } + if (doIDetectPropQA) { + histos.fill(HIST("AntiLambda/h4dPosDetectPropVsCentrality"), centrality, posTrackExtra.detectorMap(), posTrackExtra.itsClusterMap(), v0.pt()); + histos.fill(HIST("AntiLambda/h4dNegDetectPropVsCentrality"), centrality, negTrackExtra.detectorMap(), negTrackExtra.itsClusterMap(), v0.pt()); + } } } // end systematics / qa } From dd1ff0cab75a9da36ed74998740694f7e708334c Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Sun, 24 Mar 2024 19:50:35 +0100 Subject: [PATCH 4/6] Fix problematic use of filters --- PWGLF/TableProducer/cascademcfinder.cxx | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/PWGLF/TableProducer/cascademcfinder.cxx b/PWGLF/TableProducer/cascademcfinder.cxx index a565fdf3819..d2b6e9a1b80 100644 --- a/PWGLF/TableProducer/cascademcfinder.cxx +++ b/PWGLF/TableProducer/cascademcfinder.cxx @@ -82,10 +82,6 @@ struct cascademcfinder { // For manual sliceBy Preslice perMcCollision = aod::mcparticle::mcCollisionId; - // declarative filtering for particles of interest - // pre-filter on PDG and on very broad rapidity window - Filter mcParticleFilter = nabs(o2::aod::mcparticle::y) < yPreFilter && (nabs(o2::aod::mcparticle::pdgCode) == 3312 || nabs(o2::aod::mcparticle::pdgCode) == 3334); - std::vector casccollisionId; std::vector cascv0Index; std::vector cascbachelorIndex; @@ -251,7 +247,7 @@ struct cascademcfinder { return reconstructed; } - void process(soa::Join const& mcCollisions, LabeledTracks const& tracks, soa::Filtered const& allMcParticles, LabeledFullV0s const& v0s) + void process(soa::Join const& mcCollisions, LabeledTracks const& tracks, aod::McParticles const& allMcParticles, LabeledFullV0s const& v0s) { casccollisionId.clear(); cascbachelorIndex.clear(); @@ -275,6 +271,9 @@ struct cascademcfinder { bool bachelorTPCITS = false; bool reconstructed = false; for (auto& mcParticle : mcParticles) { + if(fabs(mcParticle.y()) < yPreFilter) + continue; // non-declarative skip necessary + if (mcParticle.pdgCode() == 3312 && findXiMinus) { reconstructed = ProcessCascade(mcParticle, tracks, v0s, bestCollisionIndex, positiveITS, negativeITS, bachelorITS, positiveTPC, negativeTPC, bachelorTPC, positiveTPCITS, negativeTPCITS, bachelorTPCITS); if (fabs(mcParticle.y()) < 0.5) { From 7c529271a42c6b20bebb8b20f7bf7100c34b20c1 Mon Sep 17 00:00:00 2001 From: ALICE Builder Date: Sun, 24 Mar 2024 19:52:33 +0100 Subject: [PATCH 5/6] Please consider the following formatting changes (#266) --- PWGLF/TableProducer/cascademcfinder.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/cascademcfinder.cxx b/PWGLF/TableProducer/cascademcfinder.cxx index d2b6e9a1b80..412586f3dcc 100644 --- a/PWGLF/TableProducer/cascademcfinder.cxx +++ b/PWGLF/TableProducer/cascademcfinder.cxx @@ -271,7 +271,7 @@ struct cascademcfinder { bool bachelorTPCITS = false; bool reconstructed = false; for (auto& mcParticle : mcParticles) { - if(fabs(mcParticle.y()) < yPreFilter) + if (fabs(mcParticle.y()) < yPreFilter) continue; // non-declarative skip necessary if (mcParticle.pdgCode() == 3312 && findXiMinus) { From 7d8800bb5ad8afa0e941a9c7fb53dc8153ca840f Mon Sep 17 00:00:00 2001 From: ddobrigk Date: Sun, 24 Mar 2024 19:53:18 +0100 Subject: [PATCH 6/6] Update cascademcfinder.cxx --- PWGLF/TableProducer/cascademcfinder.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/cascademcfinder.cxx b/PWGLF/TableProducer/cascademcfinder.cxx index 412586f3dcc..b737c84b601 100644 --- a/PWGLF/TableProducer/cascademcfinder.cxx +++ b/PWGLF/TableProducer/cascademcfinder.cxx @@ -271,7 +271,7 @@ struct cascademcfinder { bool bachelorTPCITS = false; bool reconstructed = false; for (auto& mcParticle : mcParticles) { - if (fabs(mcParticle.y()) < yPreFilter) + if (fabs(mcParticle.y()) > yPreFilter) continue; // non-declarative skip necessary if (mcParticle.pdgCode() == 3312 && findXiMinus) {