From 6bd5cdf5c30e0c033f2f8c4cca77dbfe6057df0e Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 9 Apr 2026 20:44:46 +0000 Subject: [PATCH] Please consider the following formatting changes --- .../PseudorapidityDensityMFT.cxx | 1921 ++++++++--------- 1 file changed, 950 insertions(+), 971 deletions(-) diff --git a/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx b/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx index bb831ef59fc..95dc1d4d3a5 100644 --- a/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx +++ b/PWGLF/Tasks/GlobalEventProperties/PseudorapidityDensityMFT.cxx @@ -17,13 +17,20 @@ #include "PWGMM/Mult/DataModel/bestCollisionTable.h" +#include "Common/Core/trackUtilities.h" #include "Common/DataModel/Centrality.h" +#include "Common/DataModel/CollisionAssociationTables.h" #include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/McCollisionExtra.h" #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/TrackSelectionTables.h" -#include "Common/DataModel/McCollisionExtra.h" +#include "CCDB/BasicCCDBManager.h" +#include "CommonConstants/GeomConstants.h" #include "CommonConstants/MathConstants.h" +#include "DataFormatsParameters/GRPMagField.h" +#include "DetectorsBase/Propagator.h" +#include "Field/MagneticField.h" #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" #include "Framework/AnalysisTask.h" @@ -33,26 +40,14 @@ #include "Framework/runDataProcessing.h" #include "MathUtils/Utils.h" #include "ReconstructionDataFormats/GlobalTrackID.h" -#include "DetectorsBase/Propagator.h" #include "ReconstructionDataFormats/TrackFwd.h" #include "ReconstructionDataFormats/TrackParametrization.h" -#include "Math/SMatrix.h" -#include "Math/SVector.h" - -#include "Common/Core/trackUtilities.h" -#include "Common/DataModel/CollisionAssociationTables.h" - -#include "CCDB/BasicCCDBManager.h" -#include "CommonConstants/GeomConstants.h" -#include "DataFormatsParameters/GRPMagField.h" -#include "Field/MagneticField.h" #include "Math/MatrixFunctions.h" -#include "TGeoGlobalMagField.h" - - - +#include "Math/SMatrix.h" +#include "Math/SVector.h" #include "TFile.h" +#include "TGeoGlobalMagField.h" #include #include @@ -70,7 +65,6 @@ using namespace o2::framework::expressions; using namespace o2::aod::track; using namespace o2::aod::rctsel; - AxisSpec ptAxis = {2001, -0.005, 20.005}; AxisSpec deltazAxis = {6100, -6.1, 6.1}; AxisSpec zAxis = {3001, -30.1, 30.1}; @@ -82,9 +76,9 @@ AxisSpec etaAxis = {18, -4.6, -1.}; // AxisSpec dcaYAxis = {2000, -10, 10};// previous AxisSpec dcaYAxis = {2000, -10, 10}; AxisSpec dcaXyAxis = {6000, -30, 30}; -AxisSpec dcaZAxis = {6000, -30, 30}; -AxisSpec dcaXAxis = {6000, -30, 30}; -AxisSpec dcaYAxis = {6000, -30, 30};// previous AxisSpec dcaYAxis = {2000, -10, 10}; +AxisSpec dcaZAxis = {6000, -30, 30}; +AxisSpec dcaXAxis = {6000, -30, 30}; +AxisSpec dcaYAxis = {6000, -30, 30}; // previous AxisSpec dcaYAxis = {2000, -10, 10}; // AxisSpec dcaXyAxis = {600, -0.15f, 0.15f}; // AxisSpec dcaZAxis = {600, -0.15f, 0.15f}; @@ -94,8 +88,7 @@ AxisSpec dcaYAxis = {6000, -30, 30};// previous AxisSpec dcaYAxis = {2000, -10 // Keep bin width = 0.0005 cm (5 um): range [-1, 1] cm => 2.0/0.0005 = 4000 bins // AxisSpec axisBinsDCA = {600, -0.15f, 0.15f, "#it{dca}_{xy} (cm)"}; - -AxisSpec centAxis = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 100}}; +AxisSpec centAxis = {{0, 10, 20, 30, 40, 50, 60, 70, 80, 100}}; // Vertex position axes (cm) AxisSpec vxAxis = {200, -0.5, 0.5, "V_{x} (cm)"}; @@ -124,26 +117,26 @@ static constexpr TrackSelectionFlags::flagtype TrackSelectionDca = using FullBCs = soa::Join; using MFTTracksLabeled = - soa::Join; - using MFTTracksLabeled3d = + aod::McMFTTrackLabels>; +using MFTTracksLabeled3d = soa::Join; using MFTTracksLabeled2d = soa::Join; + aod::McMFTTrackLabels>; - using MFTTracksLabeledOrg = +using MFTTracksLabeledOrg = soa::Join; -//using McCollisionsWithExtra = soa::Join; + aod::McMFTTrackLabels>; +// using McCollisionsWithExtra = soa::Join; using McCollisionsWithExtra = o2::soa::Join; using SMatrix55 = ROOT::Math::SMatrix>; -using SMatrix5 = ROOT::Math::SVector; +using SMatrix5 = ROOT::Math::SVector; struct PseudorapidityDensityMFT { SliceCache cache; Preslice perCol = o2::aod::fwdtrack::collisionId; @@ -153,7 +146,7 @@ struct PseudorapidityDensityMFT { Service pdg; // --- CCDB magnetic field (needed for propagateToDCAhelix in this device) --- -Service ccdbMgr; + Service ccdbMgr; Configurable ccdburlMag{"ccdburlMag", "http://alice-ccdb.cern.ch", "CCDB url for GRPMagField"}; Configurable grpmagPathMag{"grpmagPathMag", "GLO/Config/GRPMagField", @@ -165,23 +158,23 @@ Service ccdbMgr; static constexpr double CenterMft[3] = {0., 0., -61.4}; enum class GenRecoCutBin : int { - AllRecoCollisions = 1, - UseContBestCollisionIndex, - HasMcCollision, - IsTriggerTVX, - NoTimeFrameBorder, - NoITSROFrameBorder, - NoSameBunchPileup, - GoodZvtxFT0vsPV, - NoCollInRofStandard, - NoCollInRofStrict, - NoCollInTimeRangeStandard, - NoCollInTimeRangeStrict, - NoHighMultCollInPrevRof, - RctMFT, - VzWindow, - InelGt0 -}; + AllRecoCollisions = 1, + UseContBestCollisionIndex, + HasMcCollision, + IsTriggerTVX, + NoTimeFrameBorder, + NoITSROFrameBorder, + NoSameBunchPileup, + GoodZvtxFT0vsPV, + NoCollInRofStandard, + NoCollInRofStrict, + NoCollInTimeRangeStandard, + NoCollInTimeRangeStrict, + NoHighMultCollInPrevRof, + RctMFT, + VzWindow, + InelGt0 + }; enum class TrackLabelSummaryBin : int { AllTracks = 1, @@ -192,94 +185,92 @@ Service ccdbMgr; SecondaryTracks }; -enum class GenRecoTimeComTrackMode : int { - AllNonOrphan = 0, - NonOrphanNonAmbiguous, - NonOrphanAmbiguous -}; - -enum class RightWrongBin : int { - Right = 1, - Wrong, - Neither, - Both -}; -enum class EventSelectionBin : int { - All = 1, - Vz, - VzItsRof, - VzSelected, - Sel8VzInelGt0, - SelInelInelFwdGt0, - Rejected, - GoodBCs, - BCsWithCollisions, - BCsWithPileupSplitting, - PerCollisionSampleGt0, - MidtracksAndPerCollisionSampleGt0 -}; -enum class HashTableRowCountsBin : int { - RowsSaved = 1, - UniqueRecoColsSaved, - UniqueBestRecoCols -}; -enum class WrongVertexRecoExistsBin : int { - RecoOfTrueExists = 1, - RecoOfTrueMissing -}; -enum class BoolBin : int { - No = 0, - Yes = 1 -}; -enum class SingleCountBin : int { - Count = 1 -}; -enum class EventEfficiencyBin : int { - Generated = 1, - GeneratedInelGt0, - Reconstructed, - Selected, - SelectedInelGt0 -}; -enum class CentralitySelectionBin : int { - All = 1, - Selected, - Rejected -}; -enum class NeitherReasonBin : int { - NotTrueByLabel = 1, - BestColInvalid, - BestColMissingInRecoToMc, - ClassifiedRight, - ClassifiedWrong -}; - -static constexpr float ForwardEtaMax = -2.0f; -static constexpr float ForwardEtaMin = -3.9f; + enum class GenRecoTimeComTrackMode : int { + AllNonOrphan = 0, + NonOrphanNonAmbiguous, + NonOrphanAmbiguous + }; -static constexpr float PhiVetoLow = 0.02f; -static constexpr float PhiVetoPiMin = 3.10f; -static constexpr float PhiVetoPiMax = 3.23f; -static constexpr float PhiVetoHigh = 6.21f; + enum class RightWrongBin : int { + Right = 1, + Wrong, + Neither, + Both + }; + enum class EventSelectionBin : int { + All = 1, + Vz, + VzItsRof, + VzSelected, + Sel8VzInelGt0, + SelInelInelFwdGt0, + Rejected, + GoodBCs, + BCsWithCollisions, + BCsWithPileupSplitting, + PerCollisionSampleGt0, + MidtracksAndPerCollisionSampleGt0 + }; + enum class HashTableRowCountsBin : int { + RowsSaved = 1, + UniqueRecoColsSaved, + UniqueBestRecoCols + }; + enum class WrongVertexRecoExistsBin : int { + RecoOfTrueExists = 1, + RecoOfTrueMissing + }; + enum class BoolBin : int { + No = 0, + Yes = 1 + }; + enum class SingleCountBin : int { + Count = 1 + }; + enum class EventEfficiencyBin : int { + Generated = 1, + GeneratedInelGt0, + Reconstructed, + Selected, + SelectedInelGt0 + }; + enum class CentralitySelectionBin : int { + All = 1, + Selected, + Rejected + }; + enum class NeitherReasonBin : int { + NotTrueByLabel = 1, + BestColInvalid, + BestColMissingInRecoToMc, + ClassifiedRight, + ClassifiedWrong + }; -static constexpr float NdfScale = 2.0f; -static constexpr float NdfOffset = 5.0f; -static constexpr float MinNdf = 1.0f; + static constexpr float ForwardEtaMax = -2.0f; + static constexpr float ForwardEtaMin = -3.9f; + static constexpr float PhiVetoLow = 0.02f; + static constexpr float PhiVetoPiMin = 3.10f; + static constexpr float PhiVetoPiMax = 3.23f; + static constexpr float PhiVetoHigh = 6.21f; -template -static float getTrackNdf(TrackT const& track) -{ - return std::max(NdfScale * track.nClusters() - NdfOffset, MinNdf); -} -static constexpr int NoCompatibleCollisions = 0; -static constexpr int SingleCompatibleCollision = 1; + static constexpr float NdfScale = 2.0f; + static constexpr float NdfOffset = 5.0f; + static constexpr float MinNdf = 1.0f; -static constexpr int OrphanAmbDegree = 0; -static constexpr int NonAmbiguousAmbDegree = 1; + template + static float getTrackNdf(TrackT const& track) + { + return std::max(NdfScale * track.nClusters() - NdfOffset, MinNdf); + } + static constexpr int NoCompatibleCollisions = 0; + static constexpr int SingleCompatibleCollision = 1; -static constexpr int ChargeUnitTimesThree = 3; + static constexpr int OrphanAmbDegree = 0; + static constexpr int NonAmbiguousAmbDegree = 1; + static constexpr int ChargeUnitTimesThree = 3; void initMagField(FullBCs::iterator const& bc) { @@ -309,13 +300,12 @@ static constexpr int ChargeUnitTimesThree = 3; } } - RCTFlagsChecker rctChecker{"CBT"}; RCTFlagsChecker myChecker{kFT0Bad, kITSBad, kTPCBadTracking, kTPCBadPID, kMFTBad}; Configurable maxGenRecoEvents{"maxGenRecoEvents", -1, - "Maximum number of MC collisions to process in processGenReco (-1 = all)"}; + "Maximum number of MC collisions to process in processGenReco (-1 = all)"}; -int nProcessedGenReco = 0; + int nProcessedGenReco = 0; Configurable estimatorEta{"estimatorEta", 1.0, "eta range for INEL>0 sample definition"}; @@ -368,9 +358,9 @@ int nProcessedGenReco = 0; Configurable maxDCAz{"maxDCAz", 2.0f, "Cut on dcaZ"}; Configurable useLostByCutVeto{"useLostByCutVeto", true, "Reject tracks with lostNoRecoOfTrue or lostRecoExistsButNotCompatible"}; -Configurable cfgGenRecoTimeComTrackMode{"cfgGenRecoTimeComTrackMode", - static_cast(GenRecoTimeComTrackMode::AllNonOrphan), - "processGenRecoTimeCom track mode: AllNonOrphan=0, NonOrphanNonAmbiguous=1, NonOrphanAmbiguous=2"}; + Configurable cfgGenRecoTimeComTrackMode{"cfgGenRecoTimeComTrackMode", + static_cast(GenRecoTimeComTrackMode::AllNonOrphan), + "processGenRecoTimeCom track mode: AllNonOrphan=0, NonOrphanNonAmbiguous=1, NonOrphanAmbiguous=2"}; HistogramRegistry registry{ "registry", @@ -400,9 +390,9 @@ Configurable cfgGenRecoTimeComTrackMode{"cfgGenRecoTimeComTrackMode", void init(InitContext&) { -ccdbMgr->setURL(ccdburlMag.value); // or ccdburlMag.value (depending on your Configurable) -ccdbMgr->setCaching(true); -ccdbMgr->setLocalObjectValidityChecking(); + ccdbMgr->setURL(ccdburlMag.value); // or ccdburlMag.value (depending on your Configurable) + ccdbMgr->setCaching(true); + ccdbMgr->setLocalObjectValidityChecking(); if (static_cast(doprocessMult) + static_cast(doprocessMultReassoc) + @@ -417,18 +407,18 @@ ccdbMgr->setLocalObjectValidityChecking(); AxisSpec multAxis = {multBinning, "N_{trk}"}; auto hstat = registry.get(HIST("EventSelection")); auto* x = hstat->GetXaxis(); -x->SetBinLabel(static_cast(EventSelectionBin::All), "All"); -x->SetBinLabel(static_cast(EventSelectionBin::Vz), "Vz"); -x->SetBinLabel(static_cast(EventSelectionBin::VzItsRof), "Vz+ITSRof"); -x->SetBinLabel(static_cast(EventSelectionBin::VzSelected), "Vz+Selected"); -x->SetBinLabel(static_cast(EventSelectionBin::Sel8VzInelGt0), "Sel8+Vz+INEL>0"); -x->SetBinLabel(static_cast(EventSelectionBin::SelInelInelFwdGt0), "Sel INEL,INEL_fwd>0"); -x->SetBinLabel(static_cast(EventSelectionBin::Rejected), "Rejected"); -x->SetBinLabel(static_cast(EventSelectionBin::GoodBCs), "Good BCs"); -x->SetBinLabel(static_cast(EventSelectionBin::BCsWithCollisions), "BCs with collisions"); -x->SetBinLabel(static_cast(EventSelectionBin::BCsWithPileupSplitting), "BCs with pile-up/splitting"); -x->SetBinLabel(static_cast(EventSelectionBin::PerCollisionSampleGt0), "percollisionSample>0"); -x->SetBinLabel(static_cast(EventSelectionBin::MidtracksAndPerCollisionSampleGt0), "midtracks+percollisionSample>0"); + x->SetBinLabel(static_cast(EventSelectionBin::All), "All"); + x->SetBinLabel(static_cast(EventSelectionBin::Vz), "Vz"); + x->SetBinLabel(static_cast(EventSelectionBin::VzItsRof), "Vz+ITSRof"); + x->SetBinLabel(static_cast(EventSelectionBin::VzSelected), "Vz+Selected"); + x->SetBinLabel(static_cast(EventSelectionBin::Sel8VzInelGt0), "Sel8+Vz+INEL>0"); + x->SetBinLabel(static_cast(EventSelectionBin::SelInelInelFwdGt0), "Sel INEL,INEL_fwd>0"); + x->SetBinLabel(static_cast(EventSelectionBin::Rejected), "Rejected"); + x->SetBinLabel(static_cast(EventSelectionBin::GoodBCs), "Good BCs"); + x->SetBinLabel(static_cast(EventSelectionBin::BCsWithCollisions), "BCs with collisions"); + x->SetBinLabel(static_cast(EventSelectionBin::BCsWithPileupSplitting), "BCs with pile-up/splitting"); + x->SetBinLabel(static_cast(EventSelectionBin::PerCollisionSampleGt0), "percollisionSample>0"); + x->SetBinLabel(static_cast(EventSelectionBin::MidtracksAndPerCollisionSampleGt0), "midtracks+percollisionSample>0"); registry.add({"EventsNtrkZvtx", "; N_{trk}; #it{z}_{vtx} (cm); events", {HistType::kTH2F, {multAxis, zAxis}}}); @@ -451,134 +441,127 @@ x->SetBinLabel(static_cast(EventSelectionBin::MidtracksAndPerCollisionSampl " ; DCA_{XY} (cm)", {HistType::kTH1F, {dcaXyAxis}}}); - if (doprocessGenReco3d || doprocessGenReco2d || doprocessGenRecoTimeCom) { - registry.add({"EventsRecoCuts_GenReco", + registry.add({"EventsRecoCuts_GenReco", ";cut;events", {HistType::kTH1F, {{16, 0.5, 16.5}}}}); { auto h = registry.get(HIST("EventsRecoCuts_GenReco")); auto* x = h->GetXaxis(); -x->SetBinLabel(static_cast(GenRecoCutBin::AllRecoCollisions), "All reco collisions (loop entry)"); -x->SetBinLabel(static_cast(GenRecoCutBin::UseContBestCollisionIndex), "useContBestcollisionIndex"); -x->SetBinLabel(static_cast(GenRecoCutBin::HasMcCollision), "has_mcCollision()"); -x->SetBinLabel(static_cast(GenRecoCutBin::IsTriggerTVX), "kIsTriggerTVX (if useEvSel)"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoTimeFrameBorder), "kNoTimeFrameBorder (if useEvSel)"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoITSROFrameBorder), "kNoITSROFrameBorder (if useEvSel)"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoSameBunchPileup), "kNoSameBunchPileup"); -x->SetBinLabel(static_cast(GenRecoCutBin::GoodZvtxFT0vsPV), "kIsGoodZvtxFT0vsPV"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInRofStandard), "kNoCollInRofStandard (cfg)"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInRofStrict), "kNoCollInRofStrict (cfg)"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInTimeRangeStandard), "kNoCollInTimeRangeStandard (cfg)"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInTimeRangeStrict), "kNoCollInTimeRangeStrict (cfg)"); -x->SetBinLabel(static_cast(GenRecoCutBin::NoHighMultCollInPrevRof), "kNoHighMultCollInPrevRof (cfg)"); -x->SetBinLabel(static_cast(GenRecoCutBin::RctMFT), "myChecker (cfg)"); -x->SetBinLabel(static_cast(GenRecoCutBin::VzWindow), "Vz window"); -x->SetBinLabel(static_cast(GenRecoCutBin::InelGt0), "INEL>0 (midtracks>0)"); + x->SetBinLabel(static_cast(GenRecoCutBin::AllRecoCollisions), "All reco collisions (loop entry)"); + x->SetBinLabel(static_cast(GenRecoCutBin::UseContBestCollisionIndex), "useContBestcollisionIndex"); + x->SetBinLabel(static_cast(GenRecoCutBin::HasMcCollision), "has_mcCollision()"); + x->SetBinLabel(static_cast(GenRecoCutBin::IsTriggerTVX), "kIsTriggerTVX (if useEvSel)"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoTimeFrameBorder), "kNoTimeFrameBorder (if useEvSel)"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoITSROFrameBorder), "kNoITSROFrameBorder (if useEvSel)"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoSameBunchPileup), "kNoSameBunchPileup"); + x->SetBinLabel(static_cast(GenRecoCutBin::GoodZvtxFT0vsPV), "kIsGoodZvtxFT0vsPV"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInRofStandard), "kNoCollInRofStandard (cfg)"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInRofStrict), "kNoCollInRofStrict (cfg)"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInTimeRangeStandard), "kNoCollInTimeRangeStandard (cfg)"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoCollInTimeRangeStrict), "kNoCollInTimeRangeStrict (cfg)"); + x->SetBinLabel(static_cast(GenRecoCutBin::NoHighMultCollInPrevRof), "kNoHighMultCollInPrevRof (cfg)"); + x->SetBinLabel(static_cast(GenRecoCutBin::RctMFT), "myChecker (cfg)"); + x->SetBinLabel(static_cast(GenRecoCutBin::VzWindow), "Vz window"); + x->SetBinLabel(static_cast(GenRecoCutBin::InelGt0), "INEL>0 (midtracks>0)"); // x->SetBinLabel(11, "rctChecker (cfg)"); - - + // x->SetBinLabel(15, "Passed all event cuts"); } -AxisSpec trackLabelAxis = {6, 0.5, 6.5, "Track label category"}; -registry.add({"Purity/TrackLabelSummary", - ";Track label category;Counts", - {HistType::kTH1D, {trackLabelAxis}}}); -{ - auto h = registry.get(HIST("Purity/TrackLabelSummary")); - auto* x = h->GetXaxis(); - x->SetBinLabel(static_cast(TrackLabelSummaryBin::AllTracks), "All tracks"); - x->SetBinLabel(static_cast(TrackLabelSummaryBin::NoMcLabel), "No MC label"); - x->SetBinLabel(static_cast(TrackLabelSummaryBin::FakeTracks), "Fake tracks"); - x->SetBinLabel(static_cast(TrackLabelSummaryBin::TrueTracks), "True tracks"); - x->SetBinLabel(static_cast(TrackLabelSummaryBin::PrimaryTracks), "Primary tracks"); - x->SetBinLabel(static_cast(TrackLabelSummaryBin::SecondaryTracks), "Secondary tracks"); -} -registry.add({"Purity/TrackEtaCategorySparse", - ";#eta_{all};#eta_{noMC};#eta_{fake};#eta_{true};#eta_{primary};#eta_{secondary}", - {HistType::kTHnSparseF, {etaBinning, etaBinning, etaBinning, - etaBinning, etaBinning, etaBinning}}}); - - - -registry.add({"Purity/WrongVertexRecoExists", - ";status;Counts", - {HistType::kTH1F, {{2, 0.5, 2.5}}}}); -{ - auto h = registry.get(HIST("Purity/WrongVertexRecoExists")); - if (h) { -h->GetXaxis()->SetBinLabel(static_cast(WrongVertexRecoExistsBin::RecoOfTrueExists), "Reco of true exists"); -h->GetXaxis()->SetBinLabel(static_cast(WrongVertexRecoExistsBin::RecoOfTrueMissing), "Reco of true missing"); - } -} + AxisSpec trackLabelAxis = {6, 0.5, 6.5, "Track label category"}; + registry.add({"Purity/TrackLabelSummary", + ";Track label category;Counts", + {HistType::kTH1D, {trackLabelAxis}}}); + { + auto h = registry.get(HIST("Purity/TrackLabelSummary")); + auto* x = h->GetXaxis(); + x->SetBinLabel(static_cast(TrackLabelSummaryBin::AllTracks), "All tracks"); + x->SetBinLabel(static_cast(TrackLabelSummaryBin::NoMcLabel), "No MC label"); + x->SetBinLabel(static_cast(TrackLabelSummaryBin::FakeTracks), "Fake tracks"); + x->SetBinLabel(static_cast(TrackLabelSummaryBin::TrueTracks), "True tracks"); + x->SetBinLabel(static_cast(TrackLabelSummaryBin::PrimaryTracks), "Primary tracks"); + x->SetBinLabel(static_cast(TrackLabelSummaryBin::SecondaryTracks), "Secondary tracks"); + } + registry.add({"Purity/TrackEtaCategorySparse", + ";#eta_{all};#eta_{noMC};#eta_{fake};#eta_{true};#eta_{primary};#eta_{secondary}", + {HistType::kTHnSparseF, {etaBinning, etaBinning, etaBinning, etaBinning, etaBinning, etaBinning}}}); + + registry.add({"Purity/WrongVertexRecoExists", + ";status;Counts", + {HistType::kTH1F, {{2, 0.5, 2.5}}}}); + { + auto h = registry.get(HIST("Purity/WrongVertexRecoExists")); + if (h) { + h->GetXaxis()->SetBinLabel(static_cast(WrongVertexRecoExistsBin::RecoOfTrueExists), "Reco of true exists"); + h->GetXaxis()->SetBinLabel(static_cast(WrongVertexRecoExistsBin::RecoOfTrueMissing), "Reco of true missing"); + } + } -registry.add({"Purity/HashTableRowCounts", - ";status;counts", - {HistType::kTH1F, {{3, 0.5, 3.5}}}}); -auto hHashTableRowCounts = registry.get(HIST("Purity/HashTableRowCounts")); -auto* xHash = hHashTableRowCounts->GetXaxis(); -xHash->SetBinLabel(static_cast(HashTableRowCountsBin::RowsSaved), "rows saved"); -xHash->SetBinLabel(static_cast(HashTableRowCountsBin::UniqueRecoColsSaved), "unique recoCol saved"); -xHash->SetBinLabel(static_cast(HashTableRowCountsBin::UniqueBestRecoCols), "unique bestRecoCol"); + registry.add({"Purity/HashTableRowCounts", + ";status;counts", + {HistType::kTH1F, {{3, 0.5, 3.5}}}}); + auto hHashTableRowCounts = registry.get(HIST("Purity/HashTableRowCounts")); + auto* xHash = hHashTableRowCounts->GetXaxis(); + xHash->SetBinLabel(static_cast(HashTableRowCountsBin::RowsSaved), "rows saved"); + xHash->SetBinLabel(static_cast(HashTableRowCountsBin::UniqueRecoColsSaved), "unique recoCol saved"); + xHash->SetBinLabel(static_cast(HashTableRowCountsBin::UniqueBestRecoCols), "unique bestRecoCol"); registry.add({"Purity/THnDCAChosenVsRight_Wrong", - ";#eta;DCA_{xy}^{chosen} (cm);DCA_{xy}^{calculated} (cm);DCA_{xy}^{right} (cm);DCA_{z}^{chosen} (cm);DCA_{z}^{calculated} (cm);DCA_{z}^{right} (cm)", - {HistType::kTHnSparseF, {etaBinning, dcaXyAxis, dcaXyAxis,dcaXyAxis,dcaZAxis, dcaZAxis,dcaZAxis}}}); + ";#eta;DCA_{xy}^{chosen} (cm);DCA_{xy}^{calculated} (cm);DCA_{xy}^{right} (cm);DCA_{z}^{chosen} (cm);DCA_{z}^{calculated} (cm);DCA_{z}^{right} (cm)", + {HistType::kTHnSparseF, {etaBinning, dcaXyAxis, dcaXyAxis, dcaXyAxis, dcaZAxis, dcaZAxis, dcaZAxis}}}); registry.add({"Purity/THnDCAChosenVsRight_Right", - ";#eta;DCA_{xy}^{chosen} (cm);DCA_{xy}^{calculated} (cm);DCA_{xy}^{right} (cm);DCA_{z}^{chosen} (cm);DCA_{z}^{calculated} (cm);DCA_{z}^{right} (cm)", - {HistType::kTHnSparseF, {etaBinning, dcaXyAxis, dcaXyAxis,dcaXyAxis,dcaZAxis, dcaZAxis,dcaZAxis}}}); + ";#eta;DCA_{xy}^{chosen} (cm);DCA_{xy}^{calculated} (cm);DCA_{xy}^{right} (cm);DCA_{z}^{chosen} (cm);DCA_{z}^{calculated} (cm);DCA_{z}^{right} (cm)", + {HistType::kTHnSparseF, {etaBinning, dcaXyAxis, dcaXyAxis, dcaXyAxis, dcaZAxis, dcaZAxis, dcaZAxis}}}); registry.add("Purity/RecoOfTrueExists", - "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); + "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); registry.add("Purity/RecoOfTrueInCompatible", - "Reco collision(s) of true MC event present in track compatible collisions;inCompatible (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); - registry.add("Purity/RecoOfTrueExistsR", - "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); + "Reco collision(s) of true MC event present in track compatible collisions;inCompatible (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); + registry.add("Purity/RecoOfTrueExistsR", + "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); registry.add("Purity/RecoOfTrueInCompatibleR", - "Reco collision(s) of true MC event present in track compatible collisions;inCompatible (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); - - registry.add("Purity/RecoOfTrueExistsW", - "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); - registry.add("Purity/RecoOfTrueInCompatibleW", - "Reco collision(s) of true MC event present in track compatible collisions;inCompatible (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); - - registry.add("Purity/hCorrectRecoIDinTheListR", - "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); - registry.add("Purity/hCorrectRecoIDinTheListW", - "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); - - // P(Nch): number of selected MFT tracks per accepted reco collision (after all event+track cuts) - // Tracks lost because of the OR cut ( !exists || !inCompatible ) -registry.add("Purity/LostByBoth", - "Tracks rejected by (!recoOfTrueExists || !recoOfTrueInCompatible);status (0=kept,1=lost);tracks", - kTH1F, {{2, -0.5, 1.5}}); -// Number of ITS-TPC contributors to the reconstructed collision (PV contributors) -registry.add({"Purity/reco/CollisionNumContrib", - ";N_{contrib} ( PV contributors);collisions", - {HistType::kTH1F, {{3001, -0.5, 3000.5}}}}); - -// Tracks that were WRONG (by your definition) BEFORE applying the cut -registry.add("Purity/WrongBeforeRecoOfTrueCut", - "Tracks classified wrong BEFORE applying recoOfTrue cut;wrong (0=no,1=yes);tracks", - kTH1F, {{2, -0.5, 1.5}}); - -// Optional but very useful: intersection (lost AND wrong) - - - -registry.add({"Purity/reco/PNchMFT_afterCuts", - ";N_{trk}^{MFT} (selected);events", - {HistType::kTH1F, {multAxis}}}); - registry.add({"Purity/DCAyVsDCAx_Right", - ";DCA_{x} (cm);DCA_{y} (cm)", - {HistType::kTH2F, {dcaXAxis, dcaYAxis}}}); + "Reco collision(s) of true MC event present in track compatible collisions;inCompatible (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); + + registry.add("Purity/RecoOfTrueExistsW", + "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); + registry.add("Purity/RecoOfTrueInCompatibleW", + "Reco collision(s) of true MC event present in track compatible collisions;inCompatible (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); + + registry.add("Purity/hCorrectRecoIDinTheListR", + "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); + registry.add("Purity/hCorrectRecoIDinTheListW", + "Any reco collision exists for track true MC collision id;exists (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); + + // P(Nch): number of selected MFT tracks per accepted reco collision (after all event+track cuts) + // Tracks lost because of the OR cut ( !exists || !inCompatible ) + registry.add("Purity/LostByBoth", + "Tracks rejected by (!recoOfTrueExists || !recoOfTrueInCompatible);status (0=kept,1=lost);tracks", + kTH1F, {{2, -0.5, 1.5}}); + // Number of ITS-TPC contributors to the reconstructed collision (PV contributors) + registry.add({"Purity/reco/CollisionNumContrib", + ";N_{contrib} ( PV contributors);collisions", + {HistType::kTH1F, {{3001, -0.5, 3000.5}}}}); + + // Tracks that were WRONG (by your definition) BEFORE applying the cut + registry.add("Purity/WrongBeforeRecoOfTrueCut", + "Tracks classified wrong BEFORE applying recoOfTrue cut;wrong (0=no,1=yes);tracks", + kTH1F, {{2, -0.5, 1.5}}); + + // Optional but very useful: intersection (lost AND wrong) + + registry.add({"Purity/reco/PNchMFT_afterCuts", + ";N_{trk}^{MFT} (selected);events", + {HistType::kTH1F, {multAxis}}}); + registry.add({"Purity/DCAyVsDCAx_Right", + ";DCA_{x} (cm);DCA_{y} (cm)", + {HistType::kTH2F, {dcaXAxis, dcaYAxis}}}); registry.add({"Purity/reco/woOrp/All", ";bin;counts", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); @@ -597,21 +580,17 @@ registry.add({"Purity/reco/PNchMFT_afterCuts", registry.add({"EventsReco", "; status; events", {HistType::kTH1F, {{7, 0.5, 7.5}}}}); - - - - // Additional histograms for processGenReco (w/o orphan), grouped under Purity/reco/ registry.add({"Purity/reco/weakStrange/SelectedTracksEta", - "; #eta; selected reco tracks from weak strange decays", - {HistType::kTH1F, {etaBinning}}}); - registry.add({"Purity/reco/weakStrange/SelectedTracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); selected reco tracks from weak strange decays", - {HistType::kTH2F, {etaBinning, zAxis}}}); - registry.add({"Purity/reco/SelectedTracksEta", - "; #eta; selected reco tracks", - {HistType::kTH1F, {etaBinning}}}); + "; #eta; selected reco tracks from weak strange decays", + {HistType::kTH1F, {etaBinning}}}); + registry.add({"Purity/reco/weakStrange/SelectedTracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); selected reco tracks from weak strange decays", + {HistType::kTH2F, {etaBinning, zAxis}}}); + registry.add({"Purity/reco/SelectedTracksEta", + "; #eta; selected reco tracks", + {HistType::kTH1F, {etaBinning}}}); registry.add({"Purity/reco/woOrp/nTrk", " ; N_{Trk}^{all}", {HistType::kTH1F, {{701, -0.5, 700.5}}}}); @@ -779,39 +758,39 @@ registry.add({"Purity/reco/PNchMFT_afterCuts", {HistType::kTH2F, {phiAxis, etaBinning}}}); // Fake reason breakdown: 1-INEL>0 true (vz), 2-Reco sel (woOrp), 3-has_mcParticle, 4-isPrimary, 5-rightVertex - // --- Purity calculation histograms (as profiles: purity = ) --- + // --- Purity calculation histograms (as profiles: purity = ) --- registry.add({"Purity/PurityOverall", ";bin;purity", {HistType::kTProfile, {{1, 0.5, 1.5}}}}); registry.add({"Purity/PurityVsEta", ";#eta;purity", {HistType::kTProfile, {etaBinning}}}); - registry.add({"RightWrong", + registry.add({"RightWrong", ";category;counts", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hrw = registry.get(HIST("RightWrong")); -hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Right), "right"); -hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Wrong), "wrong"); -hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Neither), "neither"); -hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Both), "both"); - -registry.add("Purity/NeitherReason", "Purity/NeitherReason", kTH1D, {{5, 0.5, 5.5}}, false); -auto hNeitherReason = registry.get(HIST("Purity/NeitherReason")); -auto* xNeitherReason = hNeitherReason->GetXaxis(); -xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::NotTrueByLabel), "NotTrueByLabel"); -xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::BestColInvalid), "BestColInvalid"); -xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::BestColMissingInRecoToMc), "BestColMissingInRecoToMc"); -xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::ClassifiedRight), "ClassifiedRight"); -xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::ClassifiedWrong), "ClassifiedWrong"); - - registry.add({"Purity/RightWrongLater", + hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Right), "right"); + hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Wrong), "wrong"); + hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Neither), "neither"); + hrw->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Both), "both"); + + registry.add("Purity/NeitherReason", "Purity/NeitherReason", kTH1D, {{5, 0.5, 5.5}}, false); + auto hNeitherReason = registry.get(HIST("Purity/NeitherReason")); + auto* xNeitherReason = hNeitherReason->GetXaxis(); + xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::NotTrueByLabel), "NotTrueByLabel"); + xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::BestColInvalid), "BestColInvalid"); + xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::BestColMissingInRecoToMc), "BestColMissingInRecoToMc"); + xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::ClassifiedRight), "ClassifiedRight"); + xNeitherReason->SetBinLabel(static_cast(NeitherReasonBin::ClassifiedWrong), "ClassifiedWrong"); + + registry.add({"Purity/RightWrongLater", ";category;counts", {HistType::kTH1F, {{4, 0.5, 4.5}}}}); auto hrw1 = registry.get(HIST("Purity/RightWrongLater")); -hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Right), "right"); -hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Wrong), "wrong"); -hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Neither), "neither"); -hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Both), "both"); + hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Right), "right"); + hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Wrong), "wrong"); + hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Neither), "neither"); + hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Both), "both"); // Vertex-position difference for wrong-vertex associations (reco - true MC) registry.add({"deltaVZ_fromReco", @@ -854,8 +833,7 @@ hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Both), "both"); {HistType::kTHnSparseF, {vxAxis, vyAxis, zAxis}}}); registry.add({"Purity/VtxXYZReco", "; V_{x} (cm); V_{y} (cm); V_{z} (cm)", - {HistType::kTHnSparseF, { vxAxis, vyAxis, zAxis}}}); - + {HistType::kTHnSparseF, {vxAxis, vyAxis, zAxis}}}); // Delta vertex positions (reco - true) registry.add({"Purity/DeltaVtxXYZ", @@ -888,7 +866,6 @@ hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Both), "both"); {HistType::kTHnSparseF, {etaBinning, dcaXyAxis, dcaZAxis, dcaXAxis, dcaYAxis}}}); - registry.add({"Purity/RecoSparsePrimary", ";#eta;DCA_{xy} (cm);DCA_{z} (cm);DCA_{x} (cm);DCA_{y} (cm)", {HistType::kTHnSparseF, @@ -1000,22 +977,25 @@ hrw1->GetXaxis()->SetBinLabel(static_cast(RightWrongBin::Both), "both"); ";#Delta DCA_{xy} (cm);#Delta DCA_{z} (cm);#Delta DCA_{x} (cm);#Delta DCA_{y} (cm) (secondary, wrong vertex)", {HistType::kTHnSparseF, {dcaXyAxis, dcaZAxis, dcaXAxis, dcaYAxis}}}); - - registry.add({"Purity/RecoSparseAll_EventCount", - ";events;counts", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); - registry.add({"Purity/RecoSparseAll_EventCountBest", - ";events;counts", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); -registry.add({"Purity/RecoSparseRightAll_EventCount", - ";events;counts", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); -registry.add({"Purity/RecoSparseWrongAll_EventCount", - ";events;counts", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); -registry.add({"Purity/BestRecoColNotFound", - ";events;counts", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); -registry.add({"Purity/TrueColNotFound", - ";events;counts", {HistType::kTH1F, {{1, 0.5, 1.5}}}}); - - + registry.add({"Purity/RecoSparseAll_EventCount", + ";events;counts", + {HistType::kTH1F, {{1, 0.5, 1.5}}}}); + registry.add({"Purity/RecoSparseAll_EventCountBest", + ";events;counts", + {HistType::kTH1F, {{1, 0.5, 1.5}}}}); + registry.add({"Purity/RecoSparseRightAll_EventCount", + ";events;counts", + {HistType::kTH1F, {{1, 0.5, 1.5}}}}); + registry.add({"Purity/RecoSparseWrongAll_EventCount", + ";events;counts", + {HistType::kTH1F, {{1, 0.5, 1.5}}}}); + registry.add({"Purity/BestRecoColNotFound", + ";events;counts", + {HistType::kTH1F, {{1, 0.5, 1.5}}}}); + registry.add({"Purity/TrueColNotFound", + ";events;counts", + {HistType::kTH1F, {{1, 0.5, 1.5}}}}); } if (doprocessGen) { @@ -1083,11 +1063,11 @@ registry.add({"Purity/TrueColNotFound", registry.add({"EventsSplitMult", " ; N_{gen}", {HistType::kTH1F, {multAxis}}}); auto heff = registry.get(HIST("EventEfficiency")); x = heff->GetXaxis(); -x->SetBinLabel(static_cast(EventEfficiencyBin::Generated), "Generated"); -x->SetBinLabel(static_cast(EventEfficiencyBin::GeneratedInelGt0), "Generated INEL>0"); -x->SetBinLabel(static_cast(EventEfficiencyBin::Reconstructed), "Reconstructed"); -x->SetBinLabel(static_cast(EventEfficiencyBin::Selected), "Selected"); -x->SetBinLabel(static_cast(EventEfficiencyBin::SelectedInelGt0), "Selected INEL>0"); + x->SetBinLabel(static_cast(EventEfficiencyBin::Generated), "Generated"); + x->SetBinLabel(static_cast(EventEfficiencyBin::GeneratedInelGt0), "Generated INEL>0"); + x->SetBinLabel(static_cast(EventEfficiencyBin::Reconstructed), "Reconstructed"); + x->SetBinLabel(static_cast(EventEfficiencyBin::Selected), "Selected"); + x->SetBinLabel(static_cast(EventEfficiencyBin::SelectedInelGt0), "Selected INEL>0"); } if (doprocessMultReassoc || doprocessMultReassoc3d) { @@ -1104,8 +1084,6 @@ x->SetBinLabel(static_cast(EventEfficiencyBin::SelectedInelGt0), "Selected " ; isAmbiguous", {HistType::kTH1I, {{2, -0.5, 1.5}}}}); - - registry.add({"Tracks/Control/ReassignedTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); tracks", {HistType::kTH2F, {etaBinning, zAxis}}}); @@ -1236,9 +1214,9 @@ x->SetBinLabel(static_cast(EventEfficiencyBin::SelectedInelGt0), "Selected {HistType::kTH2F, {{3, 0.5, 3.5}, centAxis}}}); auto hstat = registry.get(HIST("Events/Centrality/Selection")); auto* x = hstat->GetXaxis(); -x->SetBinLabel(static_cast(CentralitySelectionBin::All), "All"); -x->SetBinLabel(static_cast(CentralitySelectionBin::Selected), "Selected"); -x->SetBinLabel(static_cast(CentralitySelectionBin::Rejected), "Rejected"); + x->SetBinLabel(static_cast(CentralitySelectionBin::All), "All"); + x->SetBinLabel(static_cast(CentralitySelectionBin::Selected), "Selected"); + x->SetBinLabel(static_cast(CentralitySelectionBin::Rejected), "Rejected"); registry.add({"Events/Centrality/NtrkZvtx", "; N_{trk}; Z_{vtx} (cm); centrality", @@ -1317,7 +1295,7 @@ x->SetBinLabel(static_cast(CentralitySelectionBin::Rejected), "Rejected"); if (!useEvSel || (useEvSel && ((bc.selection_bit(aod::evsel::kIsBBT0A) && bc.selection_bit(aod::evsel::kIsBBT0C)) != 0))) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::GoodBCs)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::GoodBCs)); cols.clear(); for (const auto& collision : collisions) { if (collision.has_foundBC()) { @@ -1330,38 +1308,38 @@ registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::GoodBC } LOGP(debug, "BC {} has {} collisions", bc.globalBC(), cols.size()); if (!cols.empty()) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::BCsWithCollisions)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::BCsWithCollisions)); if (cols.size() > 1) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::BCsWithPileupSplitting)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::BCsWithPileupSplitting)); } } } } } -bool passGenRecoTrackMode(auto const& track) const -{ - const auto compatibleColls = track.compatibleCollIds(); - const auto nCompatibleColls = compatibleColls.size(); - - if (nCompatibleColls == NoCompatibleCollisions) { - return false; - } + bool passGenRecoTrackMode(auto const& track) const + { + const auto compatibleColls = track.compatibleCollIds(); + const auto nCompatibleColls = compatibleColls.size(); - const auto mode = - static_cast(cfgGenRecoTimeComTrackMode.value); - - switch (mode) { - case GenRecoTimeComTrackMode::AllNonOrphan: - return nCompatibleColls > NoCompatibleCollisions; - case GenRecoTimeComTrackMode::NonOrphanNonAmbiguous: - return nCompatibleColls == SingleCompatibleCollision; - case GenRecoTimeComTrackMode::NonOrphanAmbiguous: - return nCompatibleColls > SingleCompatibleCollision; - default: + if (nCompatibleColls == NoCompatibleCollisions) { return false; + } + + const auto mode = + static_cast(cfgGenRecoTimeComTrackMode.value); + + switch (mode) { + case GenRecoTimeComTrackMode::AllNonOrphan: + return nCompatibleColls > NoCompatibleCollisions; + case GenRecoTimeComTrackMode::NonOrphanNonAmbiguous: + return nCompatibleColls == SingleCompatibleCollision; + case GenRecoTimeComTrackMode::NonOrphanAmbiguous: + return nCompatibleColls > SingleCompatibleCollision; + default: + return false; + } } -} PROCESS_SWITCH(PseudorapidityDensityMFT, processTagging, "Collect event sample stats", true); @@ -1370,7 +1348,7 @@ bool passGenRecoTrackMode(auto const& track) const static constexpr float SampleEtaMin = -3.2f; Partition sample = - (aod::fwdtrack::eta < SampleEtaMax) && (aod::fwdtrack::eta > SampleEtaMin); + (aod::fwdtrack::eta < SampleEtaMax) && (aod::fwdtrack::eta > SampleEtaMin); static constexpr float CentralEtaMax = 1.f; Partition sampleCentral = (nabs(aod::track::eta) < CentralEtaMax); @@ -1383,7 +1361,7 @@ bool passGenRecoTrackMode(auto const& track) const (aod::fwdtrack::eta < ForwardEtaMax) && (aod::fwdtrack::eta > ForwardEtaMin) && (nabs(aod::fwdtrack::bestDCAXY) <= MaxBestDcaXy); - + using CollwEv = soa::Join; expressions::Filter trackSelectionCentral = @@ -1405,9 +1383,9 @@ bool passGenRecoTrackMode(auto const& track) const FiCentralTracks const& midtracks, aod::Tracks const&) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::All)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::All)); if (!useEvSel || (useEvSel && collision.sel8())) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzSelected)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzSelected)); auto z = collision.posZ(); auto perCollisionSample = sampleCentral->sliceByCached( o2::aod::track::collisionId, collision.globalIndex(), cache); @@ -1417,7 +1395,7 @@ registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzSele if (midtracks.size() > 0) // INEL>0 { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Sel8VzInelGt0)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Sel8VzInelGt0)); registry.fill(HIST("EventsNtrkZvtx_gt0"), nTrk, z); } @@ -1450,7 +1428,7 @@ registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Sel8Vz } } else { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Rejected)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Rejected)); } } @@ -1463,7 +1441,7 @@ registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Reject RetracksT const& retracks, FiCentralTracks const& midtracks, aod::Tracks const&) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::All)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::All)); auto perCollisionSample = sampleCentral->sliceByCached( o2::aod::track::collisionId, collision.globalIndex(), cache); auto nTrk = perCollisionSample.size(); @@ -1471,10 +1449,10 @@ registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::All)); registry.fill(HIST("EventsNtrkZvtx"), nTrk, z); if ((z >= cfgVzCut1) && (z <= cfgVzCut2)) { registry.fill(HIST("Tracks/2Danalysis/EventsNtrkZvtx_all"), nTrk, z); -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Vz)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Vz)); for (const auto& retrack : retracks) { auto track = retrack.mfttrack(); -float ndf = getTrackNdf(track); + float ndf = getTrackNdf(track); float chi2ndf = track.chi2() / ndf; float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -1504,9 +1482,9 @@ float ndf = getTrackNdf(track); if (!disableITSROFCut && !collision.selection_bit(aod::evsel::kNoITSROFrameBorder)) { return; } -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzItsRof)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzItsRof)); if (!useEvSel || (useEvSel && collision.selection_bit(aod::evsel::kIsTriggerTVX) && collision.selection_bit(aod::evsel::kNoTimeFrameBorder) && collision.selection_bit(aod::evsel::kNoSameBunchPileup))) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzSelected)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzSelected)); registry.fill(HIST("Tracks/2Danalysis/EventsNtrkZvtx_sel8"), nTrk, z); std::unordered_set uniqueEvents; std::unordered_set uniqueEventsAmb; @@ -1515,20 +1493,21 @@ registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::VzSele std::unordered_set eventsInelMFT; std::unordered_set eventsInel; if (midtracks.size() > 0) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Sel8VzInelGt0)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Sel8VzInelGt0)); registry.fill(HIST("EventsNtrkZvtx_gt0"), nTrk, z); registry.fill(HIST("Tracks/2Danalysis/EventsNtrkZvtx_sel8_inelgt0"), nTrk, z); eventsInel.insert(collision.globalIndex()); } if (perCollisionSample.size() > 0) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::PerCollisionSampleGt0)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::PerCollisionSampleGt0)); } if (midtracks.size() > 0 && perCollisionSample.size() > 0) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::MidtracksAndPerCollisionSampleGt0)); } + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::MidtracksAndPerCollisionSampleGt0)); + } int64_t i = 0.0, j = 0.0, k = 0.0; for (const auto& retrack : retracks) { auto track = retrack.mfttrack(); -float ndf = getTrackNdf(track); + float ndf = getTrackNdf(track); float chi2ndf = track.chi2() / ndf; float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); @@ -1560,13 +1539,13 @@ float ndf = getTrackNdf(track); } } if (retracks.size() > 0) { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::SelInelInelFwdGt0)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::SelInelInelFwdGt0)); if (midtracks.size() > 0) { registry.fill(HIST("Tracks/2Danalysis/EventsNtrkZvtx_sel8_inelfwdgt0"), nTrk, z); } for (const auto& retrack : retracks) { auto track = retrack.mfttrack(); -float ndf = getTrackNdf(track); + float ndf = getTrackNdf(track); float chi2ndf = track.chi2() / ndf; float phi = track.phi(); float dcaXyCut = retrack.bestDCAXY(); @@ -1693,18 +1672,18 @@ float ndf = getTrackNdf(track); } if ((retrack.ambDegree() > 1) || (retrack.ambDegree() <= 1)) - if (retrack.ambDegree() != 0) { - registry.fill(HIST("Tracks/Control/woOrp/woOrpTracksEtaZvtx"), - track.eta(), z); - registry.fill(HIST("Tracks/Control/woOrp/woOrpTracksPhiEta"), phi, - track.eta()); - registry.fill(HIST("Tracks/Control/woOrp/woOrpVertexCorr"), - track.template collision_as().posZ(), z); - registry.fill(HIST("Tracks/Control/woOrp/DCAxy_woOrp"), retrack.bestDCAXY()); - if constexpr (std::is_same_v>) { - registry.fill(HIST("Tracks/Control/woOrp/DCAz_woOrp"), retrack.bestDCAZ()); + if (retrack.ambDegree() != 0) { + registry.fill(HIST("Tracks/Control/woOrp/woOrpTracksEtaZvtx"), + track.eta(), z); + registry.fill(HIST("Tracks/Control/woOrp/woOrpTracksPhiEta"), phi, + track.eta()); + registry.fill(HIST("Tracks/Control/woOrp/woOrpVertexCorr"), + track.template collision_as().posZ(), z); + registry.fill(HIST("Tracks/Control/woOrp/DCAxy_woOrp"), retrack.bestDCAXY()); + if constexpr (std::is_same_v>) { + registry.fill(HIST("Tracks/Control/woOrp/DCAz_woOrp"), retrack.bestDCAZ()); + } } - } } } registry.fill(HIST("ambEventCounts"), 1, uniqueEventsAmb.size()); @@ -1719,7 +1698,7 @@ float ndf = getTrackNdf(track); registry.fill(HIST("hNumCollisions_Inel"), 1, eventsInel.size()); } } else { -registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Rejected)); + registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Rejected)); } } @@ -1840,7 +1819,7 @@ registry.fill(HIST("EventSelection"), static_cast(EventSelectionBin::Reject } if ((mcCollision.posZ() >= cfgVzCut1) && (mcCollision.posZ() <= cfgVzCut2)) { if (nChargedCentral > 0) { -registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::GeneratedInelGt0)); + registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::GeneratedInelGt0)); registry.fill(HIST("EventsNtrkZvtxGen_gt0t"), nCharged, mcCollision.posZ()); } @@ -1853,7 +1832,7 @@ registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::Gene LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); for (const auto& collision : collisions) { -registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::Reconstructed)); + registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::Reconstructed)); if (!disableITSROFCut && !collision.selection_bit(aod::evsel::kNoITSROFrameBorder)) { return; } @@ -1862,12 +1841,12 @@ registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::Reco auto perCollisionSample = sample->sliceByCached( o2::aod::fwdtrack::collisionId, collision.globalIndex(), cache); - registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::Selected)); + registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::Selected)); auto perCollisionSampleCentral = midtracks.sliceBy(perColCentral, collision.globalIndex()); if ((collision.posZ() >= cfgVzCut1) && (collision.posZ() <= cfgVzCut2) && (mcCollision.posZ() >= cfgVzCut1) && (mcCollision.posZ() <= cfgVzCut2)) { if (perCollisionSampleCentral.size() > 0) { -registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::SelectedInelGt0)); + registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::SelectedInelGt0)); atLeastOneGt0 = true; registry.fill(HIST("EventsNtrkZvtxGen_gt0"), perCollisionSample.size(), collision.posZ()); @@ -1908,9 +1887,10 @@ registry.fill(HIST("EventEfficiency"), static_cast(EventEfficiencyBin::Sele float ptCut = particle.pt(); if (usePhiCut) { -if ((phi <= PhiVetoLow) || - ((phi >= PhiVetoPiMin) && (phi <= PhiVetoPiMax)) || - (phi >= PhiVetoHigh)) continue; + if ((phi <= PhiVetoLow) || + ((phi >= PhiVetoPiMin) && (phi <= PhiVetoPiMax)) || + (phi >= PhiVetoHigh)) + continue; } if (usePtCut) { if (ptCut > cfgnPt) @@ -2065,7 +2045,7 @@ if ((phi <= PhiVetoLow) || PROCESS_SWITCH(PseudorapidityDensityMFT, processGenPt, "Process particle-level info of pt", false); - void processGenRecoTimeCom(McCollisionsWithExtra::iterator const& mcCollision, + void processGenRecoTimeCom(McCollisionsWithExtra::iterator const& mcCollision, o2::soa::SmallGroups> const& collisions, MFTTracksLabeledOrg const& tracks, FiCentralTracks const& midtracks, @@ -2233,7 +2213,7 @@ if ((phi <= PhiVetoLow) || int bin = static_cast(RightWrongBin::Neither); bool recoOfTrueExists = false; - ///const int bestColID = track.bestCollisionId(); + /// const int bestColID = track.bestCollisionId(); const int mcOfTrack = isTrueByLabel ? track.mcParticle().mcCollisionId() : InvalidCollisionId; if (isTrueByLabel) { @@ -2329,701 +2309,700 @@ if ((phi <= PhiVetoLow) || } PROCESS_SWITCH(PseudorapidityDensityMFT, processGenRecoTimeCom, "Process for MC time compatible", false); - // using MFTTracksLabeled = soa::Join; // using MFTTracksLabeled =soa::Join; // aod::MFTTracks const& tracks -//soa::Join::iterator const& mcCollision -//aod::McCollisions::iterator const& mcCollision -//McCollisionsWithExtra::iterator const& mcCollision - -template -void processGenReco(McCollisionsWithExtra::iterator const& mcCollision, - o2::soa::SmallGroups> const& collisions, - FullBCs const& bcs, - MFTTracksT const& tracks, Particles const& particles, - FiCentralTracks const& midtracks, - aod::McParticles const&) -{ - const auto fillGenRecoCut = [&](GenRecoCutBin bin) { - registry.fill(HIST("EventsRecoCuts_GenReco"), static_cast(bin)); - }; - fillGenRecoCut(GenRecoCutBin::AllRecoCollisions); - - std::unordered_map recoToMc; - std::unordered_map> mcToReco; - std::unordered_set acceptedRecoCols; - std::unordered_map recoVtxX; - std::unordered_map recoVtxY; - std::unordered_map recoVtxZ; - std::unordered_set recoCollisionIds; - std::unordered_set trueMCCollisionIds; - std::unordered_map> recoVtxByRecoId; - std::unordered_map> recoVtxByMcId; - - recoToMc.reserve(collisions.size()); - mcToReco.reserve(collisions.size()); - acceptedRecoCols.reserve(collisions.size()); - recoCollisionIds.reserve(collisions.size()); - trueMCCollisionIds.reserve(collisions.size()); - recoVtxByRecoId.reserve(collisions.size()); - recoVtxByMcId.reserve(collisions.size()); - - bool magInited = false; - for (auto const& bc : bcs) { - initMagField(bc); - magInited = true; - break; - } - if (!magInited) { - LOGF(fatal, "BC table is empty: cannot initialize magnetic field"); - } + // soa::Join::iterator const& mcCollision + // aod::McCollisions::iterator const& mcCollision + // McCollisionsWithExtra::iterator const& mcCollision - const auto countAndPassEvSelGenReco = [&](auto const& collision) { - struct EvSelStep { - bool enabled; - decltype(aod::evsel::kIsTriggerTVX) bit; - GenRecoCutBin bin; + template + void processGenReco(McCollisionsWithExtra::iterator const& mcCollision, + o2::soa::SmallGroups> const& collisions, + FullBCs const& bcs, + MFTTracksT const& tracks, Particles const& particles, + FiCentralTracks const& midtracks, + aod::McParticles const&) + { + const auto fillGenRecoCut = [&](GenRecoCutBin bin) { + registry.fill(HIST("EventsRecoCuts_GenReco"), static_cast(bin)); }; + fillGenRecoCut(GenRecoCutBin::AllRecoCollisions); - const std::array steps = {{ - {true, aod::evsel::kIsTriggerTVX, GenRecoCutBin::IsTriggerTVX}, - {true, aod::evsel::kNoTimeFrameBorder, GenRecoCutBin::NoTimeFrameBorder}, - {true, aod::evsel::kNoITSROFrameBorder, GenRecoCutBin::NoITSROFrameBorder}, - {useNoSameBunchPileup, aod::evsel::kNoSameBunchPileup, GenRecoCutBin::NoSameBunchPileup}, - {useGoodZvtxFT0vsPV, aod::evsel::kIsGoodZvtxFT0vsPV, GenRecoCutBin::GoodZvtxFT0vsPV}, - {useNoCollInRofStandard, aod::evsel::kNoCollInRofStandard, GenRecoCutBin::NoCollInRofStandard}, - {useNoCollInRofStrict, aod::evsel::kNoCollInRofStrict, GenRecoCutBin::NoCollInRofStrict}, - {useNoCollInTimeRangeStandard, aod::evsel::kNoCollInTimeRangeStandard, GenRecoCutBin::NoCollInTimeRangeStandard}, - {useNoCollInTimeRangeStrict, aod::evsel::kNoCollInTimeRangeStrict, GenRecoCutBin::NoCollInTimeRangeStrict}, - {useNoHighMultCollInPrevRof, aod::evsel::kNoHighMultCollInPrevRof, GenRecoCutBin::NoHighMultCollInPrevRof}, - }}; - - if (!useEvSel) { - for (const auto& step : steps) { - fillGenRecoCut(step.bin); - } - fillGenRecoCut(GenRecoCutBin::RctMFT); - return true; - } - - for (const auto& step : steps) { - if (!step.enabled) { - fillGenRecoCut(step.bin); - continue; - } - - if (!collision.selection_bit(step.bit)) { - return false; - } - fillGenRecoCut(step.bin); - } + std::unordered_map recoToMc; + std::unordered_map> mcToReco; + std::unordered_set acceptedRecoCols; + std::unordered_map recoVtxX; + std::unordered_map recoVtxY; + std::unordered_map recoVtxZ; + std::unordered_set recoCollisionIds; + std::unordered_set trueMCCollisionIds; + std::unordered_map> recoVtxByRecoId; + std::unordered_map> recoVtxByMcId; - if (useRctMFT && !myChecker(collision)) { - return false; + recoToMc.reserve(collisions.size()); + mcToReco.reserve(collisions.size()); + acceptedRecoCols.reserve(collisions.size()); + recoCollisionIds.reserve(collisions.size()); + trueMCCollisionIds.reserve(collisions.size()); + recoVtxByRecoId.reserve(collisions.size()); + recoVtxByMcId.reserve(collisions.size()); + + bool magInited = false; + for (auto const& bc : bcs) { + initMagField(bc); + magInited = true; + break; } - fillGenRecoCut(GenRecoCutBin::RctMFT); - - return true; - }; - - for (const auto& collision : collisions) { - int nSavedRows = 0; - std::unordered_set uniqueRecoColsSaved; - - registry.fill(HIST("Purity/reco/CollisionNumContrib"), collision.numContrib()); - - if (useCont && collision.globalIndex() != mcCollision.bestCollisionIndex()) { - continue; + if (!magInited) { + LOGF(fatal, "BC table is empty: cannot initialize magnetic field"); } - fillGenRecoCut(GenRecoCutBin::UseContBestCollisionIndex); - if (!collision.has_mcCollision()) { - LOGP(warning, "Reco collision {} has no MC collision label, skipping", collision.globalIndex()); - continue; - } - fillGenRecoCut(GenRecoCutBin::HasMcCollision); + const auto countAndPassEvSelGenReco = [&](auto const& collision) { + struct EvSelStep { + bool enabled; + decltype(aod::evsel::kIsTriggerTVX) bit; + GenRecoCutBin bin; + }; - if (!countAndPassEvSelGenReco(collision)) { - continue; - } + const std::array steps = {{ + {true, aod::evsel::kIsTriggerTVX, GenRecoCutBin::IsTriggerTVX}, + {true, aod::evsel::kNoTimeFrameBorder, GenRecoCutBin::NoTimeFrameBorder}, + {true, aod::evsel::kNoITSROFrameBorder, GenRecoCutBin::NoITSROFrameBorder}, + {useNoSameBunchPileup, aod::evsel::kNoSameBunchPileup, GenRecoCutBin::NoSameBunchPileup}, + {useGoodZvtxFT0vsPV, aod::evsel::kIsGoodZvtxFT0vsPV, GenRecoCutBin::GoodZvtxFT0vsPV}, + {useNoCollInRofStandard, aod::evsel::kNoCollInRofStandard, GenRecoCutBin::NoCollInRofStandard}, + {useNoCollInRofStrict, aod::evsel::kNoCollInRofStrict, GenRecoCutBin::NoCollInRofStrict}, + {useNoCollInTimeRangeStandard, aod::evsel::kNoCollInTimeRangeStandard, GenRecoCutBin::NoCollInTimeRangeStandard}, + {useNoCollInTimeRangeStrict, aod::evsel::kNoCollInTimeRangeStrict, GenRecoCutBin::NoCollInTimeRangeStrict}, + {useNoHighMultCollInPrevRof, aod::evsel::kNoHighMultCollInPrevRof, GenRecoCutBin::NoHighMultCollInPrevRof}, + }}; - const auto z = collision.posZ(); - if ((z < cfgVzCut1) || (z > cfgVzCut2)) { - continue; - } - fillGenRecoCut(GenRecoCutBin::VzWindow); + if (!useEvSel) { + for (const auto& step : steps) { + fillGenRecoCut(step.bin); + } + fillGenRecoCut(GenRecoCutBin::RctMFT); + return true; + } - auto perCollisionSampleCentral = midtracks.sliceBy(perColCentral, collision.globalIndex()); - if (perCollisionSampleCentral.size() <= 0) { - continue; - } - fillGenRecoCut(GenRecoCutBin::InelGt0); + for (const auto& step : steps) { + if (!step.enabled) { + fillGenRecoCut(step.bin); + continue; + } - const int recoCol = collision.globalIndex(); - const int mcCol = collision.mcCollisionId(); + if (!collision.selection_bit(step.bit)) { + return false; + } + fillGenRecoCut(step.bin); + } - acceptedRecoCols.insert(recoCol); - recoCollisionIds.insert(recoCol); - trueMCCollisionIds.insert(mcCol); + if (useRctMFT && !myChecker(collision)) { + return false; + } + fillGenRecoCut(GenRecoCutBin::RctMFT); - if (mcCol >= 0) { - recoToMc[recoCol] = mcCol; - mcToReco[mcCol].push_back(recoCol); - ++nSavedRows; - uniqueRecoColsSaved.insert(recoCol); - } + return true; + }; - registry.fill(HIST("Purity/HashTableRowCounts"), - static_cast(HashTableRowCountsBin::RowsSaved), nSavedRows); - registry.fill(HIST("Purity/HashTableRowCounts"), - static_cast(HashTableRowCountsBin::UniqueRecoColsSaved), uniqueRecoColsSaved.size()); - - recoVtxX[recoCol] = collision.posX(); - recoVtxY[recoCol] = collision.posY(); - recoVtxZ[recoCol] = collision.posZ(); - recoVtxByRecoId[recoCol] = {collision.posX(), collision.posY(), collision.posZ()}; - recoVtxByMcId[mcCol] = {mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()}; - - registry.fill(HIST("Purity/xReco"), collision.posX()); - registry.fill(HIST("Purity/xTrue"), mcCollision.posX()); - registry.fill(HIST("Purity/yReco"), collision.posY()); - registry.fill(HIST("Purity/yTrue"), mcCollision.posY()); - registry.fill(HIST("Purity/zReco"), collision.posZ()); - registry.fill(HIST("Purity/zTrue"), mcCollision.posZ()); - registry.fill(HIST("Purity/VtxXYZTruth"), mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()); - registry.fill(HIST("Purity/VtxXYZReco"), collision.posX(), collision.posY(), collision.posZ()); - registry.fill(HIST("Purity/DeltaVtxXYZ"), - collision.posX() - mcCollision.posX(), - collision.posY() - mcCollision.posY(), - collision.posZ() - mcCollision.posZ()); - } + for (const auto& collision : collisions) { + int nSavedRows = 0; + std::unordered_set uniqueRecoColsSaved; - int64_t woOrpCount = 0; - bool filledRight = false; - bool filledWrong = false; - int nMftSelectedAfterCuts = 0; - std::unordered_set uniqueBestRecoCols; + registry.fill(HIST("Purity/reco/CollisionNumContrib"), collision.numContrib()); - if (tracks.size() > 0) { - bool countedPrimary = false; - for (const auto& track : tracks) { - float ndf = getTrackNdf(track); - float chi2ndf = track.chi2() / ndf; - float phi = track.phi(); - float dcaXyCut = track.bestDCAXY(); - float dcaZCut = 0.f; - bool failDCAzCut = false; - float ptCut = track.pt(); - constexpr bool hasBestDCAZ = requires { track.bestDCAZ(); }; - - if constexpr (hasBestDCAZ) { - dcaZCut = track.bestDCAZ(); - failDCAzCut = useDCAzCut && (std::abs(dcaZCut) > maxDCAz); + if (useCont && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; } + fillGenRecoCut(GenRecoCutBin::UseContBestCollisionIndex); - o2::math_utils::bringTo02Pi(phi); - const float etaReco = track.eta(); - const float dcaXYReco = dcaXyCut; - const float dcaZReco = hasBestDCAZ ? dcaZCut : 0.f; - const float dcaXReco = dcaXYReco * std::cos(phi); - const float dcaYReco = dcaXYReco * std::sin(phi); - - const bool failTrackCuts = - track.nClusters() < cfgnCluster || - etaReco <= cfgnEta1 || - etaReco >= cfgnEta2 || - chi2ndf >= cfgChi2NDFMax || - phi <= cfgPhiCut1 || - phi >= cfgPhiCut2 || - (usePhiCut && - ((phi <= PhiVetoLow) || - ((phi >= PhiVetoPiMin) && (phi <= PhiVetoPiMax)) || - (phi >= PhiVetoHigh))) || - (useDCAxyCut && dcaXyCut > maxDCAxy) || - failDCAzCut || - (usePtCut && ptCut > cfgnPt); - - if (failTrackCuts) { + if (!collision.has_mcCollision()) { + LOGP(warning, "Reco collision {} has no MC collision label, skipping", collision.globalIndex()); continue; } + fillGenRecoCut(GenRecoCutBin::HasMcCollision); - if (!passGenRecoTrackMode(track)) { + if (!countAndPassEvSelGenReco(collision)) { continue; } - const int recoCol = track.collisionId(); - if (acceptedRecoCols.find(recoCol) == acceptedRecoCols.end()) { + const auto z = collision.posZ(); + if ((z < cfgVzCut1) || (z > cfgVzCut2)) { continue; } + fillGenRecoCut(GenRecoCutBin::VzWindow); - auto itRecoVz = recoVtxZ.find(recoCol); - if (itRecoVz == recoVtxZ.end()) { + auto perCollisionSampleCentral = midtracks.sliceBy(perColCentral, collision.globalIndex()); + if (perCollisionSampleCentral.size() <= 0) { continue; } - const float z = itRecoVz->second; + fillGenRecoCut(GenRecoCutBin::InelGt0); - const bool hasMcLabel = track.has_mcParticle(); - const bool isFakeByLabel = hasMcLabel ? (track.mcMask() != 0) : false; - const bool isTrueByLabel = hasMcLabel && !isFakeByLabel; - const bool hasNoMcLabel = !hasMcLabel; - const bool isPrimaryCharged = hasMcLabel && !isFakeByLabel && track.mcParticle().isPhysicalPrimary(); - const bool isSecondaryCharged = hasMcLabel && !isFakeByLabel && !track.mcParticle().isPhysicalPrimary(); - const auto fillTrackLabelSummary = [&](TrackLabelSummaryBin binSummary) { - registry.fill(HIST("Purity/TrackLabelSummary"), static_cast(binSummary)); - }; + const int recoCol = collision.globalIndex(); + const int mcCol = collision.mcCollisionId(); - const auto fillTrackEtaCategory = [&](TrackLabelSummaryBin binSummary) { - constexpr float EtaSentinel = -999.f; + acceptedRecoCols.insert(recoCol); + recoCollisionIds.insert(recoCol); + trueMCCollisionIds.insert(mcCol); - float etaAll = EtaSentinel; - float etaNoMc = EtaSentinel; - float etaFake = EtaSentinel; - float etaTrue = EtaSentinel; - float etaPrimary = EtaSentinel; - float etaSecondary = EtaSentinel; + if (mcCol >= 0) { + recoToMc[recoCol] = mcCol; + mcToReco[mcCol].push_back(recoCol); + ++nSavedRows; + uniqueRecoColsSaved.insert(recoCol); + } - switch (binSummary) { - case TrackLabelSummaryBin::AllTracks: - etaAll = etaReco; - break; - case TrackLabelSummaryBin::NoMcLabel: - etaNoMc = etaReco; - break; - case TrackLabelSummaryBin::FakeTracks: - etaFake = etaReco; - break; - case TrackLabelSummaryBin::TrueTracks: - etaTrue = etaReco; - break; - case TrackLabelSummaryBin::PrimaryTracks: - etaPrimary = etaReco; - break; - case TrackLabelSummaryBin::SecondaryTracks: - etaSecondary = etaReco; - break; - } + registry.fill(HIST("Purity/HashTableRowCounts"), + static_cast(HashTableRowCountsBin::RowsSaved), nSavedRows); + registry.fill(HIST("Purity/HashTableRowCounts"), + static_cast(HashTableRowCountsBin::UniqueRecoColsSaved), uniqueRecoColsSaved.size()); - registry.fill(HIST("Purity/TrackEtaCategorySparse"), - etaAll, etaNoMc, etaFake, etaTrue, etaPrimary, etaSecondary); - }; + recoVtxX[recoCol] = collision.posX(); + recoVtxY[recoCol] = collision.posY(); + recoVtxZ[recoCol] = collision.posZ(); + recoVtxByRecoId[recoCol] = {collision.posX(), collision.posY(), collision.posZ()}; + recoVtxByMcId[mcCol] = {mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()}; + + registry.fill(HIST("Purity/xReco"), collision.posX()); + registry.fill(HIST("Purity/xTrue"), mcCollision.posX()); + registry.fill(HIST("Purity/yReco"), collision.posY()); + registry.fill(HIST("Purity/yTrue"), mcCollision.posY()); + registry.fill(HIST("Purity/zReco"), collision.posZ()); + registry.fill(HIST("Purity/zTrue"), mcCollision.posZ()); + registry.fill(HIST("Purity/VtxXYZTruth"), mcCollision.posX(), mcCollision.posY(), mcCollision.posZ()); + registry.fill(HIST("Purity/VtxXYZReco"), collision.posX(), collision.posY(), collision.posZ()); + registry.fill(HIST("Purity/DeltaVtxXYZ"), + collision.posX() - mcCollision.posX(), + collision.posY() - mcCollision.posY(), + collision.posZ() - mcCollision.posZ()); + } - fillTrackLabelSummary(TrackLabelSummaryBin::AllTracks); - fillTrackEtaCategory(TrackLabelSummaryBin::AllTracks); + int64_t woOrpCount = 0; + bool filledRight = false; + bool filledWrong = false; + int nMftSelectedAfterCuts = 0; + std::unordered_set uniqueBestRecoCols; - if (hasMcLabel) { - const auto mcPartForMother = track.mcParticle(); - if (!isPrimaryCharged && mcPartForMother.has_mothers()) { - auto mcpartMother = mcPartForMother.template mothers_as().front(); - if (mcpartMother.pdgCode() == PDG_t::kK0Short || - std::abs(mcpartMother.pdgCode()) == PDG_t::kLambda0) { - registry.fill(HIST("Purity/reco/weakStrange/SelectedTracksEta"), track.eta()); - registry.fill(HIST("Purity/reco/weakStrange/SelectedTracksEtaZvtx"), track.eta(), z); - } + if (tracks.size() > 0) { + bool countedPrimary = false; + for (const auto& track : tracks) { + float ndf = getTrackNdf(track); + float chi2ndf = track.chi2() / ndf; + float phi = track.phi(); + float dcaXyCut = track.bestDCAXY(); + float dcaZCut = 0.f; + bool failDCAzCut = false; + float ptCut = track.pt(); + constexpr bool hasBestDCAZ = requires { track.bestDCAZ(); }; + + if constexpr (hasBestDCAZ) { + dcaZCut = track.bestDCAZ(); + failDCAzCut = useDCAzCut && (std::abs(dcaZCut) > maxDCAz); } - } - if (hasNoMcLabel) { - fillTrackLabelSummary(TrackLabelSummaryBin::NoMcLabel); - fillTrackEtaCategory(TrackLabelSummaryBin::NoMcLabel); - } else if (isFakeByLabel) { - fillTrackLabelSummary(TrackLabelSummaryBin::FakeTracks); - fillTrackEtaCategory(TrackLabelSummaryBin::FakeTracks); - } else { - fillTrackLabelSummary(TrackLabelSummaryBin::TrueTracks); - fillTrackEtaCategory(TrackLabelSummaryBin::TrueTracks); + o2::math_utils::bringTo02Pi(phi); + const float etaReco = track.eta(); + const float dcaXYReco = dcaXyCut; + const float dcaZReco = hasBestDCAZ ? dcaZCut : 0.f; + const float dcaXReco = dcaXYReco * std::cos(phi); + const float dcaYReco = dcaXYReco * std::sin(phi); + + const bool failTrackCuts = + track.nClusters() < cfgnCluster || + etaReco <= cfgnEta1 || + etaReco >= cfgnEta2 || + chi2ndf >= cfgChi2NDFMax || + phi <= cfgPhiCut1 || + phi >= cfgPhiCut2 || + (usePhiCut && + ((phi <= PhiVetoLow) || + ((phi >= PhiVetoPiMin) && (phi <= PhiVetoPiMax)) || + (phi >= PhiVetoHigh))) || + (useDCAxyCut && dcaXyCut > maxDCAxy) || + failDCAzCut || + (usePtCut && ptCut > cfgnPt); + + if (failTrackCuts) { + continue; + } - if (isPrimaryCharged) { - fillTrackLabelSummary(TrackLabelSummaryBin::PrimaryTracks); - fillTrackEtaCategory(TrackLabelSummaryBin::PrimaryTracks); + if (!passGenRecoTrackMode(track)) { + continue; } - if (isSecondaryCharged) { - fillTrackLabelSummary(TrackLabelSummaryBin::SecondaryTracks); - fillTrackEtaCategory(TrackLabelSummaryBin::SecondaryTracks); + const int recoCol = track.collisionId(); + if (acceptedRecoCols.find(recoCol) == acceptedRecoCols.end()) { + continue; } - } - int bin = static_cast(RightWrongBin::Neither); - bool recoOfTrueExists = false; - bool recoOfTrueInCompatible = false; + auto itRecoVz = recoVtxZ.find(recoCol); + if (itRecoVz == recoVtxZ.end()) { + continue; + } + const float z = itRecoVz->second; + + const bool hasMcLabel = track.has_mcParticle(); + const bool isFakeByLabel = hasMcLabel ? (track.mcMask() != 0) : false; + const bool isTrueByLabel = hasMcLabel && !isFakeByLabel; + const bool hasNoMcLabel = !hasMcLabel; + const bool isPrimaryCharged = hasMcLabel && !isFakeByLabel && track.mcParticle().isPhysicalPrimary(); + const bool isSecondaryCharged = hasMcLabel && !isFakeByLabel && !track.mcParticle().isPhysicalPrimary(); + const auto fillTrackLabelSummary = [&](TrackLabelSummaryBin binSummary) { + registry.fill(HIST("Purity/TrackLabelSummary"), static_cast(binSummary)); + }; + + const auto fillTrackEtaCategory = [&](TrackLabelSummaryBin binSummary) { + constexpr float EtaSentinel = -999.f; + + float etaAll = EtaSentinel; + float etaNoMc = EtaSentinel; + float etaFake = EtaSentinel; + float etaTrue = EtaSentinel; + float etaPrimary = EtaSentinel; + float etaSecondary = EtaSentinel; + + switch (binSummary) { + case TrackLabelSummaryBin::AllTracks: + etaAll = etaReco; + break; + case TrackLabelSummaryBin::NoMcLabel: + etaNoMc = etaReco; + break; + case TrackLabelSummaryBin::FakeTracks: + etaFake = etaReco; + break; + case TrackLabelSummaryBin::TrueTracks: + etaTrue = etaReco; + break; + case TrackLabelSummaryBin::PrimaryTracks: + etaPrimary = etaReco; + break; + case TrackLabelSummaryBin::SecondaryTracks: + etaSecondary = etaReco; + break; + } - const int bestColID = track.bestCollisionId(); - const int mcOfTrack = isTrueByLabel ? track.mcParticle().mcCollisionId() : InvalidCollisionId; + registry.fill(HIST("Purity/TrackEtaCategorySparse"), + etaAll, etaNoMc, etaFake, etaTrue, etaPrimary, etaSecondary); + }; + + fillTrackLabelSummary(TrackLabelSummaryBin::AllTracks); + fillTrackEtaCategory(TrackLabelSummaryBin::AllTracks); + + if (hasMcLabel) { + const auto mcPartForMother = track.mcParticle(); + if (!isPrimaryCharged && mcPartForMother.has_mothers()) { + auto mcpartMother = mcPartForMother.template mothers_as().front(); + if (mcpartMother.pdgCode() == PDG_t::kK0Short || + std::abs(mcpartMother.pdgCode()) == PDG_t::kLambda0) { + registry.fill(HIST("Purity/reco/weakStrange/SelectedTracksEta"), track.eta()); + registry.fill(HIST("Purity/reco/weakStrange/SelectedTracksEtaZvtx"), track.eta(), z); + } + } + } - const bool foundRecoColInRecoList = - recoCollisionIds.find(recoCol) != recoCollisionIds.end(); - const bool foundBestColInRecoList = - recoCollisionIds.find(bestColID) != recoCollisionIds.end(); - const bool foundInMCTrueList = - isTrueByLabel && (trueMCCollisionIds.find(mcOfTrack) != trueMCCollisionIds.end()); - - static constexpr int RecoColMissingBin = 1; - static constexpr int BestRecoColMissingBin = 2; - static constexpr int TrueColMissingBin = 1; - if (!foundRecoColInRecoList) { - registry.fill(HIST("Purity/BestRecoColNotFound"), RecoColMissingBin); - } - if (!foundBestColInRecoList) { - registry.fill(HIST("Purity/BestRecoColNotFound"), BestRecoColMissingBin); - } - if (isTrueByLabel && !foundInMCTrueList) { - registry.fill(HIST("Purity/TrueColNotFound"), TrueColMissingBin); - } + if (hasNoMcLabel) { + fillTrackLabelSummary(TrackLabelSummaryBin::NoMcLabel); + fillTrackEtaCategory(TrackLabelSummaryBin::NoMcLabel); + } else if (isFakeByLabel) { + fillTrackLabelSummary(TrackLabelSummaryBin::FakeTracks); + fillTrackEtaCategory(TrackLabelSummaryBin::FakeTracks); + } else { + fillTrackLabelSummary(TrackLabelSummaryBin::TrueTracks); + fillTrackEtaCategory(TrackLabelSummaryBin::TrueTracks); - if (!isTrueByLabel) { - registry.fill(HIST("Purity/NeitherReason"), - static_cast(NeitherReasonBin::NotTrueByLabel)); - } else { - auto itRecoToMc = recoToMc.find(bestColID); - const auto compatibleIds = track.compatibleCollIds(); - auto itRecoList = mcToReco.find(mcOfTrack); + if (isPrimaryCharged) { + fillTrackLabelSummary(TrackLabelSummaryBin::PrimaryTracks); + fillTrackEtaCategory(TrackLabelSummaryBin::PrimaryTracks); + } - if (!compatibleIds.empty() && itRecoList != mcToReco.end() && !itRecoList->second.empty()) { - for (const auto& trueRecoId : itRecoList->second) { - for (const auto& compatibleId : compatibleIds) { - if (compatibleId == trueRecoId) { - recoOfTrueInCompatible = true; - break; - } - } - if (recoOfTrueInCompatible) { - break; - } + if (isSecondaryCharged) { + fillTrackLabelSummary(TrackLabelSummaryBin::SecondaryTracks); + fillTrackEtaCategory(TrackLabelSummaryBin::SecondaryTracks); } } - if (itRecoList != mcToReco.end() && !itRecoList->second.empty()) { - recoOfTrueExists = true; + int bin = static_cast(RightWrongBin::Neither); + bool recoOfTrueExists = false; + bool recoOfTrueInCompatible = false; + + const int bestColID = track.bestCollisionId(); + const int mcOfTrack = isTrueByLabel ? track.mcParticle().mcCollisionId() : InvalidCollisionId; + + const bool foundRecoColInRecoList = + recoCollisionIds.find(recoCol) != recoCollisionIds.end(); + const bool foundBestColInRecoList = + recoCollisionIds.find(bestColID) != recoCollisionIds.end(); + const bool foundInMCTrueList = + isTrueByLabel && (trueMCCollisionIds.find(mcOfTrack) != trueMCCollisionIds.end()); + + static constexpr int RecoColMissingBin = 1; + static constexpr int BestRecoColMissingBin = 2; + static constexpr int TrueColMissingBin = 1; + if (!foundRecoColInRecoList) { + registry.fill(HIST("Purity/BestRecoColNotFound"), RecoColMissingBin); + } + if (!foundBestColInRecoList) { + registry.fill(HIST("Purity/BestRecoColNotFound"), BestRecoColMissingBin); + } + if (isTrueByLabel && !foundInMCTrueList) { + registry.fill(HIST("Purity/TrueColNotFound"), TrueColMissingBin); } - if (bestColID < 0) { + if (!isTrueByLabel) { registry.fill(HIST("Purity/NeitherReason"), - static_cast(NeitherReasonBin::BestColInvalid)); - } else if (itRecoToMc == recoToMc.end()) { - registry.fill(HIST("Purity/NeitherReason"), - static_cast(NeitherReasonBin::BestColMissingInRecoToMc)); + static_cast(NeitherReasonBin::NotTrueByLabel)); } else { - const int mcFromReco = itRecoToMc->second; - if (mcFromReco == mcOfTrack) { - bin = static_cast(RightWrongBin::Right); + auto itRecoToMc = recoToMc.find(bestColID); + const auto compatibleIds = track.compatibleCollIds(); + auto itRecoList = mcToReco.find(mcOfTrack); + + if (!compatibleIds.empty() && itRecoList != mcToReco.end() && !itRecoList->second.empty()) { + for (const auto& trueRecoId : itRecoList->second) { + for (const auto& compatibleId : compatibleIds) { + if (compatibleId == trueRecoId) { + recoOfTrueInCompatible = true; + break; + } + } + if (recoOfTrueInCompatible) { + break; + } + } + } + + if (itRecoList != mcToReco.end() && !itRecoList->second.empty()) { + recoOfTrueExists = true; + } + + if (bestColID < 0) { registry.fill(HIST("Purity/NeitherReason"), - static_cast(NeitherReasonBin::ClassifiedRight)); - } else { - bin = static_cast(RightWrongBin::Wrong); + static_cast(NeitherReasonBin::BestColInvalid)); + } else if (itRecoToMc == recoToMc.end()) { registry.fill(HIST("Purity/NeitherReason"), - static_cast(NeitherReasonBin::ClassifiedWrong)); + static_cast(NeitherReasonBin::BestColMissingInRecoToMc)); + } else { + const int mcFromReco = itRecoToMc->second; + if (mcFromReco == mcOfTrack) { + bin = static_cast(RightWrongBin::Right); + registry.fill(HIST("Purity/NeitherReason"), + static_cast(NeitherReasonBin::ClassifiedRight)); + } else { + bin = static_cast(RightWrongBin::Wrong); + registry.fill(HIST("Purity/NeitherReason"), + static_cast(NeitherReasonBin::ClassifiedWrong)); + } } } - } - registry.fill(HIST("RightWrong"), bin); - registry.fill(HIST("Purity/RecoOfTrueExists"), - recoOfTrueExists ? static_cast(BoolBin::Yes) - : static_cast(BoolBin::No)); - registry.fill(HIST("Purity/RecoOfTrueInCompatible"), - recoOfTrueInCompatible ? static_cast(BoolBin::Yes) - : static_cast(BoolBin::No)); - - if (bestColID >= 0) { - uniqueBestRecoCols.insert(bestColID); - } - - if (bin == static_cast(RightWrongBin::Wrong)) { - registry.fill(HIST("Purity/WrongVertexRecoExists"), - recoOfTrueExists ? static_cast(WrongVertexRecoExistsBin::RecoOfTrueExists) - : static_cast(WrongVertexRecoExistsBin::RecoOfTrueMissing)); - registry.fill(HIST("Purity/RecoOfTrueExistsW"), + registry.fill(HIST("RightWrong"), bin); + registry.fill(HIST("Purity/RecoOfTrueExists"), recoOfTrueExists ? static_cast(BoolBin::Yes) : static_cast(BoolBin::No)); - registry.fill(HIST("Purity/RecoOfTrueInCompatibleW"), + registry.fill(HIST("Purity/RecoOfTrueInCompatible"), recoOfTrueInCompatible ? static_cast(BoolBin::Yes) : static_cast(BoolBin::No)); - } - if (bin == static_cast(RightWrongBin::Right)) { - registry.fill(HIST("Purity/RecoOfTrueExistsR"), - recoOfTrueExists ? static_cast(BoolBin::Yes) - : static_cast(BoolBin::No)); - registry.fill(HIST("Purity/RecoOfTrueInCompatibleR"), - recoOfTrueInCompatible ? static_cast(BoolBin::Yes) - : static_cast(BoolBin::No)); - } + if (bestColID >= 0) { + uniqueBestRecoCols.insert(bestColID); + } - registry.fill(HIST("Purity/RecoSparseAll"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + if (bin == static_cast(RightWrongBin::Wrong)) { + registry.fill(HIST("Purity/WrongVertexRecoExists"), + recoOfTrueExists ? static_cast(WrongVertexRecoExistsBin::RecoOfTrueExists) + : static_cast(WrongVertexRecoExistsBin::RecoOfTrueMissing)); + registry.fill(HIST("Purity/RecoOfTrueExistsW"), + recoOfTrueExists ? static_cast(BoolBin::Yes) + : static_cast(BoolBin::No)); + registry.fill(HIST("Purity/RecoOfTrueInCompatibleW"), + recoOfTrueInCompatible ? static_cast(BoolBin::Yes) + : static_cast(BoolBin::No)); + } - if (isPrimaryCharged) { - registry.fill(HIST("Purity/RecoSparsePrimary"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - } else { - registry.fill(HIST("Purity/RecoSparseSecondary"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - } + if (bin == static_cast(RightWrongBin::Right)) { + registry.fill(HIST("Purity/RecoOfTrueExistsR"), + recoOfTrueExists ? static_cast(BoolBin::Yes) + : static_cast(BoolBin::No)); + registry.fill(HIST("Purity/RecoOfTrueInCompatibleR"), + recoOfTrueInCompatible ? static_cast(BoolBin::Yes) + : static_cast(BoolBin::No)); + } - registry.fill(HIST("RecoSparseAllBest"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + registry.fill(HIST("Purity/RecoSparseAll"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - if (bin == static_cast(RightWrongBin::Wrong)) { - float vzBest = 999.f; - float vzTrue = 999.f; - auto itVzBest = recoVtxZ.find(bestColID); - if (itVzBest != recoVtxZ.end()) { - vzBest = itVzBest->second; - } - auto itVzTrue = recoVtxZ.find(recoCol); - if (itVzTrue != recoVtxZ.end()) { - vzTrue = itVzTrue->second; + if (isPrimaryCharged) { + registry.fill(HIST("Purity/RecoSparsePrimary"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + } else { + registry.fill(HIST("Purity/RecoSparseSecondary"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); } - double_t vztrueParticle = track.mcParticle().template mcCollision_as().posZ(); - double_t diff1 = vzBest - vztrueParticle; - double_t diff2 = vzBest - vzTrue; - registry.fill(HIST("deltaVZ_fromReco"), diff1); - registry.fill(HIST("deltaVZ_fromTrue"), diff2); - registry.fill(HIST("RecoSparseAllBestWrong"), + + registry.fill(HIST("RecoSparseAllBest"), etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - } - if (hasMcLabel) { - const auto mcColObj = track.mcParticle().template mcCollision_as(); - const auto mcPart = track.mcParticle(); + if (bin == static_cast(RightWrongBin::Wrong)) { + float vzBest = 999.f; + float vzTrue = 999.f; + auto itVzBest = recoVtxZ.find(bestColID); + if (itVzBest != recoVtxZ.end()) { + vzBest = itVzBest->second; + } + auto itVzTrue = recoVtxZ.find(recoCol); + if (itVzTrue != recoVtxZ.end()) { + vzTrue = itVzTrue->second; + } + double_t vztrueParticle = track.mcParticle().template mcCollision_as().posZ(); + double_t diff1 = vzBest - vztrueParticle; + double_t diff2 = vzBest - vzTrue; + registry.fill(HIST("deltaVZ_fromReco"), diff1); + registry.fill(HIST("deltaVZ_fromTrue"), diff2); + registry.fill(HIST("RecoSparseAllBestWrong"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + } - const auto dcaXtruth = mcPart.vx() - mcColObj.posX(); - const auto dcaYtruth = mcPart.vy() - mcColObj.posY(); - const auto dcaZtruth = hasBestDCAZ ? (mcPart.vz() - mcColObj.posZ()) : 0.f; - const auto dcaXYtruth = std::sqrt(dcaXtruth * dcaXtruth + dcaYtruth * dcaYtruth); + if (hasMcLabel) { + const auto mcColObj = track.mcParticle().template mcCollision_as(); + const auto mcPart = track.mcParticle(); - const float etaTruth = mcPart.eta(); - const bool isPrimaryTruth = mcPart.isPhysicalPrimary(); + const auto dcaXtruth = mcPart.vx() - mcColObj.posX(); + const auto dcaYtruth = mcPart.vy() - mcColObj.posY(); + const auto dcaZtruth = hasBestDCAZ ? (mcPart.vz() - mcColObj.posZ()) : 0.f; + const auto dcaXYtruth = std::sqrt(dcaXtruth * dcaXtruth + dcaYtruth * dcaYtruth); - registry.fill(HIST("Tracks/dca/Truth/THnDCAxyBestGenTruthAll"), - etaTruth, dcaXYtruth, dcaZtruth, dcaXtruth, dcaYtruth); - if (isPrimaryTruth) { - registry.fill(HIST("Tracks/dca/Truth/THnDCAxyBestGenTruthPrim"), - etaTruth, dcaXYtruth, dcaZtruth, dcaXtruth, dcaYtruth); - } else { - registry.fill(HIST("Tracks/dca/Truth/THnDCAxyBestGenTruthSec"), - etaTruth, dcaXYtruth, dcaZtruth, dcaXtruth, dcaYtruth); - } + const float etaTruth = mcPart.eta(); + const bool isPrimaryTruth = mcPart.isPhysicalPrimary(); - registry.fill(HIST("Purity/reco/woOrp/woOrpTracksEtaZvtx"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp/woOrpTracksPtZvtx"), track.pt(), z); - registry.fill(HIST("Purity/reco/woOrp/woOrpEtaZvtx_gt0"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp/woOrpPtZvtx_gt0"), track.pt(), z); - registry.fill(HIST("Purity/reco/woOrp/woOrpTracksDCAxyZvtx_gt0"), dcaXyCut, z); - registry.fill(HIST("Purity/reco/woOrp/woOrpTracksDCAzZvtx_gt0"), dcaZCut, z); - registry.fill(HIST("Purity/reco/woOrp/woOrpTracksPhiEta"), phi, track.eta()); - - if (isFakeByLabel) { - registry.fill(HIST("Purity/reco/woOrp_fake/woOrpTracksEtaZvtx"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_fake/woOrpTracksPtZvtx"), track.pt(), z); - registry.fill(HIST("Purity/reco/woOrp_fake/woOrpTracksPhiEta"), phi, track.eta()); - registry.fill(HIST("Purity/reco/woOrp_fake/woOrpEtaZvtx_gt0"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_fake/woOrpPtZvtx_gt0"), track.pt(), z); - } - if (isTrueByLabel) { - registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpTracksEtaZvtx"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpTracksPtZvtx"), track.pt(), z); - registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpTracksPhiEta"), phi, track.eta()); - registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpEtaZvtx_gt0"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpPtZvtx_gt0"), track.pt(), z); - } - if (isSecondaryCharged) { - registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpTracksEtaZvtx"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpTracksPtZvtx"), track.pt(), z); - registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpTracksPhiEta"), phi, track.eta()); - registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpEtaZvtx_gt0"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpPtZvtx_gt0"), track.pt(), z); - } - if (isPrimaryCharged) { - registry.fill(HIST("Purity/reco/woOrp_primary/woOrpTracksEtaZvtx"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_primary/woOrpTracksPtZvtx"), track.pt(), z); - registry.fill(HIST("Purity/reco/woOrp_primary/woOrpTracksPhiEta"), phi, track.eta()); - registry.fill(HIST("Purity/reco/woOrp_primary/woOrpEtaZvtx_gt0"), track.eta(), z); - registry.fill(HIST("Purity/reco/woOrp_primary/woOrpPtZvtx_gt0"), track.pt(), z); - } + registry.fill(HIST("Tracks/dca/Truth/THnDCAxyBestGenTruthAll"), + etaTruth, dcaXYtruth, dcaZtruth, dcaXtruth, dcaYtruth); + if (isPrimaryTruth) { + registry.fill(HIST("Tracks/dca/Truth/THnDCAxyBestGenTruthPrim"), + etaTruth, dcaXYtruth, dcaZtruth, dcaXtruth, dcaYtruth); + } else { + registry.fill(HIST("Tracks/dca/Truth/THnDCAxyBestGenTruthSec"), + etaTruth, dcaXYtruth, dcaZtruth, dcaXtruth, dcaYtruth); + } - ++woOrpCount; + registry.fill(HIST("Purity/reco/woOrp/woOrpTracksEtaZvtx"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp/woOrpTracksPtZvtx"), track.pt(), z); + registry.fill(HIST("Purity/reco/woOrp/woOrpEtaZvtx_gt0"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp/woOrpPtZvtx_gt0"), track.pt(), z); + registry.fill(HIST("Purity/reco/woOrp/woOrpTracksDCAxyZvtx_gt0"), dcaXyCut, z); + registry.fill(HIST("Purity/reco/woOrp/woOrpTracksDCAzZvtx_gt0"), dcaZCut, z); + registry.fill(HIST("Purity/reco/woOrp/woOrpTracksPhiEta"), phi, track.eta()); + + if (isFakeByLabel) { + registry.fill(HIST("Purity/reco/woOrp_fake/woOrpTracksEtaZvtx"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_fake/woOrpTracksPtZvtx"), track.pt(), z); + registry.fill(HIST("Purity/reco/woOrp_fake/woOrpTracksPhiEta"), phi, track.eta()); + registry.fill(HIST("Purity/reco/woOrp_fake/woOrpEtaZvtx_gt0"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_fake/woOrpPtZvtx_gt0"), track.pt(), z); + } + if (isTrueByLabel) { + registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpTracksEtaZvtx"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpTracksPtZvtx"), track.pt(), z); + registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpTracksPhiEta"), phi, track.eta()); + registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpEtaZvtx_gt0"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_hasMC/woOrpPtZvtx_gt0"), track.pt(), z); + } + if (isSecondaryCharged) { + registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpTracksEtaZvtx"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpTracksPtZvtx"), track.pt(), z); + registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpTracksPhiEta"), phi, track.eta()); + registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpEtaZvtx_gt0"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_secondary/woOrpPtZvtx_gt0"), track.pt(), z); + } + if (isPrimaryCharged) { + registry.fill(HIST("Purity/reco/woOrp_primary/woOrpTracksEtaZvtx"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_primary/woOrpTracksPtZvtx"), track.pt(), z); + registry.fill(HIST("Purity/reco/woOrp_primary/woOrpTracksPhiEta"), phi, track.eta()); + registry.fill(HIST("Purity/reco/woOrp_primary/woOrpEtaZvtx_gt0"), track.eta(), z); + registry.fill(HIST("Purity/reco/woOrp_primary/woOrpPtZvtx_gt0"), track.pt(), z); + } - const float xTrue = mcColObj.posX(); - const float yTrue = mcColObj.posY(); - const float zTrue = mcColObj.posZ(); + ++woOrpCount; - std::array dcaInfOrig{999., 999., 999.}; - std::array dcaChosen{999., 999.}; - std::array dcaRight{999., 999.}; - std::array dcaChosenXYZ{999., 999., 999.}; + const float xTrue = mcColObj.posX(); + const float yTrue = mcColObj.posY(); + const float zTrue = mcColObj.posZ(); - const double bZ = o2::base::Propagator::Instance()->getNominalBz(); + std::array dcaInfOrig{999., 999., 999.}; + std::array dcaChosen{999., 999.}; + std::array dcaRight{999., 999.}; + std::array dcaChosenXYZ{999., 999., 999.}; - std::vector v1; - SMatrix55 tcovs(v1.begin(), v1.end()); - SMatrix5 tpars(track.x(), track.y(), track.phi(), track.tgl(), track.signed1Pt()); - o2::track::TrackParCovFwd trackPar0{track.z(), tpars, tcovs, track.chi2()}; + const double bZ = o2::base::Propagator::Instance()->getNominalBz(); - auto trackPar = trackPar0; - dcaInfOrig = {999., 999., 999.}; - auto itVtxChosen = recoVtxByRecoId.find(bestColID); - if (itVtxChosen != recoVtxByRecoId.end()) { - trackPar.propagateToDCAhelix(bZ, itVtxChosen->second, dcaInfOrig); - dcaChosenXYZ = dcaInfOrig; - dcaChosen[0] = std::sqrt(dcaInfOrig[0] * dcaInfOrig[0] + dcaInfOrig[1] * dcaInfOrig[1]); - dcaChosen[1] = dcaInfOrig[2]; - } + std::vector v1; + SMatrix55 tcovs(v1.begin(), v1.end()); + SMatrix5 tpars(track.x(), track.y(), track.phi(), track.tgl(), track.signed1Pt()); + o2::track::TrackParCovFwd trackPar0{track.z(), tpars, tcovs, track.chi2()}; - dcaInfOrig = {999., 999., 999.}; - const std::array vtxTruth{xTrue, yTrue, zTrue}; - trackPar.propagateToDCAhelix(bZ, vtxTruth, dcaInfOrig); - dcaRight[0] = std::sqrt(dcaInfOrig[0] * dcaInfOrig[0] + dcaInfOrig[1] * dcaInfOrig[1]); - dcaRight[1] = dcaInfOrig[2]; + auto trackPar = trackPar0; + dcaInfOrig = {999., 999., 999.}; + auto itVtxChosen = recoVtxByRecoId.find(bestColID); + if (itVtxChosen != recoVtxByRecoId.end()) { + trackPar.propagateToDCAhelix(bZ, itVtxChosen->second, dcaInfOrig); + dcaChosenXYZ = dcaInfOrig; + dcaChosen[0] = std::sqrt(dcaInfOrig[0] * dcaInfOrig[0] + dcaInfOrig[1] * dcaInfOrig[1]); + dcaChosen[1] = dcaInfOrig[2]; + } - registry.fill(HIST("Purity/DCAyVsDCAx_Right"), dcaChosenXYZ[2], dcaChosenXYZ[1]); - if (bin == static_cast(RightWrongBin::Wrong)) { - registry.fill(HIST("Purity/THnDCAChosenVsRight_Wrong"), - etaReco, dcaXyCut, dcaChosen[0], dcaRight[0], dcaZCut, dcaChosen[1], dcaRight[1]); - } - if (bin == static_cast(RightWrongBin::Right)) { - registry.fill(HIST("Purity/THnDCAChosenVsRight_Right"), - etaReco, dcaXyCut, dcaChosen[0], dcaRight[0], dcaZCut, dcaChosen[1], dcaRight[1]); - ++nMftSelectedAfterCuts; - } + dcaInfOrig = {999., 999., 999.}; + const std::array vtxTruth{xTrue, yTrue, zTrue}; + trackPar.propagateToDCAhelix(bZ, vtxTruth, dcaInfOrig); + dcaRight[0] = std::sqrt(dcaInfOrig[0] * dcaInfOrig[0] + dcaInfOrig[1] * dcaInfOrig[1]); + dcaRight[1] = dcaInfOrig[2]; - if (bin == static_cast(RightWrongBin::Right)) { - registry.fill(HIST("Purity/RecoSparseRightAll"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - if (!filledRight) { - registry.fill(HIST("Purity/RecoSparseRightAll_EventCount"), static_cast(SingleCountBin::Count)); - filledRight = true; + registry.fill(HIST("Purity/DCAyVsDCAx_Right"), dcaChosenXYZ[2], dcaChosenXYZ[1]); + if (bin == static_cast(RightWrongBin::Wrong)) { + registry.fill(HIST("Purity/THnDCAChosenVsRight_Wrong"), + etaReco, dcaXyCut, dcaChosen[0], dcaRight[0], dcaZCut, dcaChosen[1], dcaRight[1]); } - if (isPrimaryCharged) { - registry.fill(HIST("Purity/RecoSparseRightPrimary"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - } else { - registry.fill(HIST("Purity/RecoSparseRightSecondary"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + if (bin == static_cast(RightWrongBin::Right)) { + registry.fill(HIST("Purity/THnDCAChosenVsRight_Right"), + etaReco, dcaXyCut, dcaChosen[0], dcaRight[0], dcaZCut, dcaChosen[1], dcaRight[1]); + ++nMftSelectedAfterCuts; } - } else if (bin == static_cast(RightWrongBin::Wrong)) { - registry.fill(HIST("Purity/RecoSparseWrongAll"), - etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - if (!filledWrong) { - registry.fill(HIST("Purity/RecoSparseWrongAll_EventCount"), static_cast(SingleCountBin::Count)); - filledWrong = true; - } - if (isPrimaryCharged) { - registry.fill(HIST("Purity/RecoSparseWrongPrimary"), + + if (bin == static_cast(RightWrongBin::Right)) { + registry.fill(HIST("Purity/RecoSparseRightAll"), etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - } else { - registry.fill(HIST("Purity/RecoSparseWrongSecondary"), + if (!filledRight) { + registry.fill(HIST("Purity/RecoSparseRightAll_EventCount"), static_cast(SingleCountBin::Count)); + filledRight = true; + } + if (isPrimaryCharged) { + registry.fill(HIST("Purity/RecoSparseRightPrimary"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + } else { + registry.fill(HIST("Purity/RecoSparseRightSecondary"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + } + } else if (bin == static_cast(RightWrongBin::Wrong)) { + registry.fill(HIST("Purity/RecoSparseWrongAll"), etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); - } - } - - auto itVtxX = recoVtxX.find(bestColID); - if (itVtxX != recoVtxX.end()) { - const float xReco = itVtxX->second; - const float yReco = recoVtxY[bestColID]; - const float zReco = recoVtxZ[bestColID]; - const bool recoVzIn = (zReco >= cfgVzCut1) && (zReco <= cfgVzCut2); - const bool trueVzIn = (zTrue >= cfgVzCut1) && (zTrue <= cfgVzCut2); - - if (recoVzIn && trueVzIn) { - const float deltaXvtx = xReco - xTrue; - const float deltaYvtx = yReco - yTrue; - const float deltaZvtx = zReco - zTrue; - - if (bin == static_cast(RightWrongBin::Wrong)) { - registry.fill(HIST("Purity/DeltaXWrong"), deltaXvtx); - registry.fill(HIST("Purity/DeltaYWrong"), deltaYvtx); - registry.fill(HIST("Purity/DeltaZWrong"), deltaZvtx); + if (!filledWrong) { + registry.fill(HIST("Purity/RecoSparseWrongAll_EventCount"), static_cast(SingleCountBin::Count)); + filledWrong = true; } - if (bin == static_cast(RightWrongBin::Right)) { - registry.fill(HIST("Purity/DeltaXRight"), deltaXvtx); - registry.fill(HIST("Purity/DeltaYRight"), deltaYvtx); - registry.fill(HIST("Purity/DeltaZRight"), deltaZvtx); + if (isPrimaryCharged) { + registry.fill(HIST("Purity/RecoSparseWrongPrimary"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); + } else { + registry.fill(HIST("Purity/RecoSparseWrongSecondary"), + etaReco, dcaXYReco, dcaZReco, dcaXReco, dcaYReco); } } - } - const float deltaDCAxy = dcaXYtruth - dcaXYReco; - const float deltaDCAz = dcaZtruth - dcaZReco; - const float deltaDCAx = dcaXtruth - dcaXReco; - const float deltaDCAy = dcaYtruth - dcaYReco; - if (bin == static_cast(RightWrongBin::Right)) { - registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCARightAll"), - deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); - if (isPrimaryCharged) { - registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCARightPrim"), - deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); - } else { - registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCARightSec"), - deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); + auto itVtxX = recoVtxX.find(bestColID); + if (itVtxX != recoVtxX.end()) { + const float xReco = itVtxX->second; + const float yReco = recoVtxY[bestColID]; + const float zReco = recoVtxZ[bestColID]; + const bool recoVzIn = (zReco >= cfgVzCut1) && (zReco <= cfgVzCut2); + const bool trueVzIn = (zTrue >= cfgVzCut1) && (zTrue <= cfgVzCut2); + + if (recoVzIn && trueVzIn) { + const float deltaXvtx = xReco - xTrue; + const float deltaYvtx = yReco - yTrue; + const float deltaZvtx = zReco - zTrue; + + if (bin == static_cast(RightWrongBin::Wrong)) { + registry.fill(HIST("Purity/DeltaXWrong"), deltaXvtx); + registry.fill(HIST("Purity/DeltaYWrong"), deltaYvtx); + registry.fill(HIST("Purity/DeltaZWrong"), deltaZvtx); + } + if (bin == static_cast(RightWrongBin::Right)) { + registry.fill(HIST("Purity/DeltaXRight"), deltaXvtx); + registry.fill(HIST("Purity/DeltaYRight"), deltaYvtx); + registry.fill(HIST("Purity/DeltaZRight"), deltaZvtx); + } + } } - } else { - registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCAWrongAll"), - deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); - if (isPrimaryCharged) { - registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCAWrongPrim"), + + const float deltaDCAxy = dcaXYtruth - dcaXYReco; + const float deltaDCAz = dcaZtruth - dcaZReco; + const float deltaDCAx = dcaXtruth - dcaXReco; + const float deltaDCAy = dcaYtruth - dcaYReco; + if (bin == static_cast(RightWrongBin::Right)) { + registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCARightAll"), deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); + if (isPrimaryCharged) { + registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCARightPrim"), + deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); + } else { + registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCARightSec"), + deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); + } } else { - registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCAWrongSec"), + registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCAWrongAll"), deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); + if (isPrimaryCharged) { + registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCAWrongPrim"), + deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); + } else { + registry.fill(HIST("Tracks/dca/Truth/THnDeltaDCAWrongSec"), + deltaDCAxy, deltaDCAz, deltaDCAx, deltaDCAy); + } } - } - registry.fill(HIST("Purity/mc/PrimaryAll"), static_cast(SingleCountBin::Count)); - registry.fill(HIST("Purity/mc/PrimaryAllEta"), mcPart.eta()); - registry.fill(HIST("Purity/mc/PrimaryTracksEtaZvtx"), mcPart.eta(), mcCollision.posZ()); - registry.fill(HIST("Purity/mc/PrimaryTracksEtaZvtx_gt0"), mcPart.eta(), mcCollision.posZ()); - registry.fill(HIST("Purity/mc/PrimaryTracksPtZvtx_gt0"), mcPart.pt(), mcCollision.posZ()); - registry.fill(HIST("Purity/mc/PrimaryTracksDCAxyZvtx_gt0"), dcaXyCut, mcCollision.posZ()); - registry.fill(HIST("Purity/mc/PrimaryTracksDCAzZvtx_gt0"), dcaZCut, mcCollision.posZ()); - registry.fill(HIST("Purity/mc/PrimaryTracksPhiEta"), mcPart.phi(), mcPart.eta()); - registry.fill(HIST("Purity/SelectedAfterDCAxy/PrimaryAll"), static_cast(SingleCountBin::Count)); - registry.fill(HIST("Purity/SelectedAfterDCAxy/PrimaryAllEta"), mcPart.eta()); - countedPrimary = true; - - registry.fill(HIST("Purity/PurityOverall"), - static_cast(SingleCountBin::Count), - countedPrimary ? static_cast(BoolBin::Yes) - : static_cast(BoolBin::No)); - registry.fill(HIST("Purity/PurityVsEta"), track.eta(), - countedPrimary ? static_cast(BoolBin::Yes) - : static_cast(BoolBin::No)); + registry.fill(HIST("Purity/mc/PrimaryAll"), static_cast(SingleCountBin::Count)); + registry.fill(HIST("Purity/mc/PrimaryAllEta"), mcPart.eta()); + registry.fill(HIST("Purity/mc/PrimaryTracksEtaZvtx"), mcPart.eta(), mcCollision.posZ()); + registry.fill(HIST("Purity/mc/PrimaryTracksEtaZvtx_gt0"), mcPart.eta(), mcCollision.posZ()); + registry.fill(HIST("Purity/mc/PrimaryTracksPtZvtx_gt0"), mcPart.pt(), mcCollision.posZ()); + registry.fill(HIST("Purity/mc/PrimaryTracksDCAxyZvtx_gt0"), dcaXyCut, mcCollision.posZ()); + registry.fill(HIST("Purity/mc/PrimaryTracksDCAzZvtx_gt0"), dcaZCut, mcCollision.posZ()); + registry.fill(HIST("Purity/mc/PrimaryTracksPhiEta"), mcPart.phi(), mcPart.eta()); + registry.fill(HIST("Purity/SelectedAfterDCAxy/PrimaryAll"), static_cast(SingleCountBin::Count)); + registry.fill(HIST("Purity/SelectedAfterDCAxy/PrimaryAllEta"), mcPart.eta()); + countedPrimary = true; + + registry.fill(HIST("Purity/PurityOverall"), + static_cast(SingleCountBin::Count), + countedPrimary ? static_cast(BoolBin::Yes) + : static_cast(BoolBin::No)); + registry.fill(HIST("Purity/PurityVsEta"), track.eta(), + countedPrimary ? static_cast(BoolBin::Yes) + : static_cast(BoolBin::No)); + } } } - } - registry.fill(HIST("Purity/HashTableRowCounts"), - static_cast(HashTableRowCountsBin::UniqueBestRecoCols), uniqueBestRecoCols.size()); - registry.fill(HIST("Purity/reco/woOrp/nTrk"), woOrpCount); - registry.fill(HIST("Purity/reco/PNchMFT_afterCuts"), nMftSelectedAfterCuts); -} -void processGenReco3d(McCollisionsWithExtra::iterator const& mcCollision, - o2::soa::SmallGroups> const& collisions, - FullBCs const& bcs, - MFTTracksLabeled3d const& tracks, Particles const& particles, - FiCentralTracks const& midtracks, - aod::McParticles const& mcParticles) -{ - processGenReco(mcCollision, collisions, bcs, tracks, particles, midtracks, mcParticles); -} + registry.fill(HIST("Purity/HashTableRowCounts"), + static_cast(HashTableRowCountsBin::UniqueBestRecoCols), uniqueBestRecoCols.size()); + registry.fill(HIST("Purity/reco/woOrp/nTrk"), woOrpCount); + registry.fill(HIST("Purity/reco/PNchMFT_afterCuts"), nMftSelectedAfterCuts); + } + void processGenReco3d(McCollisionsWithExtra::iterator const& mcCollision, + o2::soa::SmallGroups> const& collisions, + FullBCs const& bcs, + MFTTracksLabeled3d const& tracks, Particles const& particles, + FiCentralTracks const& midtracks, + aod::McParticles const& mcParticles) + { + processGenReco(mcCollision, collisions, bcs, tracks, particles, midtracks, mcParticles); + } -void processGenReco2d(McCollisionsWithExtra::iterator const& mcCollision, - o2::soa::SmallGroups> const& collisions, - FullBCs const& bcs, - MFTTracksLabeled2d const& tracks, Particles const& particles, - FiCentralTracks const& midtracks, - aod::McParticles const& mcParticles) -{ - processGenReco(mcCollision, collisions, bcs, tracks, particles, midtracks, mcParticles); -} -PROCESS_SWITCH(PseudorapidityDensityMFT, processGenReco3d, - "Process gen-reco info with BestCollisionsFwd3d", true); + void processGenReco2d(McCollisionsWithExtra::iterator const& mcCollision, + o2::soa::SmallGroups> const& collisions, + FullBCs const& bcs, + MFTTracksLabeled2d const& tracks, Particles const& particles, + FiCentralTracks const& midtracks, + aod::McParticles const& mcParticles) + { + processGenReco(mcCollision, collisions, bcs, tracks, particles, midtracks, mcParticles); + } + PROCESS_SWITCH(PseudorapidityDensityMFT, processGenReco3d, + "Process gen-reco info with BestCollisionsFwd3d", true); -PROCESS_SWITCH(PseudorapidityDensityMFT, processGenReco2d, - "Process gen-reco info with BestCollisionsFwd", false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processGenReco2d, + "Process gen-reco info with BestCollisionsFwd", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)