From a109d8618f45a3a25396f5045319fee91d52bc5e Mon Sep 17 00:00:00 2001 From: Gyula Bencedi Date: Tue, 22 Sep 2026 17:10:07 +0200 Subject: [PATCH] Cleanup following reassociation checks --- PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx | 3812 ++++++++++------------------ 1 file changed, 1297 insertions(+), 2515 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx index 06bc603dbfd..c5c51422118 100644 --- a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx +++ b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx @@ -44,16 +44,11 @@ #include #include #include -#include -#include -#include -#include #include #include #include #include -#include #include #include @@ -62,21 +57,14 @@ #include #include #include -#include #include -#include #include -#include #include #include #include #include -#include #include -using SMatrix55 = ROOT::Math::SMatrix>; -using SMatrix5 = ROOT::Math::SVector; - using namespace o2; using namespace o2::framework; using namespace o2::framework::expressions; @@ -89,11 +77,7 @@ using namespace o2::aod::rctsel; auto static constexpr CminCharge = 3.f; auto static constexpr CintZero = 0; -auto static constexpr CintOne = 1; -auto static constexpr Czero = 0.f; -auto static constexpr CInvalid = -999.f; -auto static constexpr Cninety = 90.f; -auto static constexpr ConeHeighty = 180.f; +auto static constexpr CfloatFive = 5.f; auto static constexpr CminAccFT0A = 3.5f; auto static constexpr CmaxAccFT0A = 4.9f; auto static constexpr CminAccFT0C = -3.3f; @@ -130,14 +114,14 @@ enum class TrkSel { nTrkSel }; -enum class TrkTrkBestSel { - trkTrkBestSelAll = 0, - trkTrkBestSelCollID, - trkTrkBestSelOrphan, - trkTrkBestSelDCAxyCut, - trkTrkBestSelDCAzCut, - trkTrkBestSelNumReassoc, - nTrkTrkBestSel +enum class TrkBestSel { + trkBestSelAll = 0, + trkBestSelCollID, + trkBestSelOrphan, + trkBestSelDCAxyCut, + trkBestSelDCAzCut, + trkBestSelNumReassoc, + nTrkBestSel }; enum class AmbTrkType { @@ -151,185 +135,75 @@ enum class AmbTrkType { nAmbTrkType }; -enum AmbTrkTypeAssocFlag { - kSelAll = 0, - kSelGoodVtx, - kSelGoodVtxTrue, - kSelBadVtx, - kSelBadVtxTrue, - kSelNonAmb, - kSelNonAmbGoodVtx, - kSelNonAmbGoodVtxTrue, - kSelNonAmbBadVtx, - kSelNonAmbBadVtxTrue, - kSelNonAmbID, - kSelNonAmbIDGoodVtxTrue, - kSelNonAmbIDBadVtxTrue, - kSelAmbID, - kSelAmbIDGoodVtxTrue, - kSelAmbIDBadVtxTrue, - kSelNonAmbIDExtra, - kSelNonAmbIDExtraGoodVtxTrue, - kSelNonAmbIDExtraBadVtxTrue, - kSelAmb, - kSelAmbGoodVtxTrue, - kSelAmbBadVtxTrue, - kSelOrphanNull, - nSelAmbTrkTypeAssocFlag +enum class GenTrkType { + kGenAll = 0, + kGenRecEvt, + nGenTrkType }; -enum class TrackToCollEvtType { - kAllRecColl = 0, - kIsInelGt0wMft, - kEvtSel, - kBestCollIdx, - kIsMcColl, - nTrackToCollEvtType +enum class GenIdxTrkType { + kGenIdxAll = 0, + kGenIdxDupl, + kGenIdxFake, + nGenIdxTrkType }; -enum class VertexStatusMC { - kNull = 0, - kGood, - kBad +enum class RecTrkType { + kRecAll = 0, + kRecFake, + nRecTrkType }; -enum class AssocCheckVtxType { - kAllVtxTrue = 0, - kAllVtxFalse, - kAllGoodVtx, - kAllGoodVtxTrue, - kAllGoodVtxFalse, - kAllBadVtx, - kAllBadVtxTrue, - kAllBadVtxFalse, - nAssocVtxType +enum class RecIdxTrkType { + kRecIdxPrim = 0, + kRecIdxSec, + kRecIdxDupl, + nRecIdxTrkType }; -enum class ReassocCheckVtxType { - kIsTrueVtxAllTrue = 0, - kIsTrueVtxAllFalse, - kIsTrueVtxVsGoodVtxTrue, - kIsTrueVtxVsGoodVtxFalse, - kIsTrueVtxVsBadVtxTrue, - kIsTrueVtxVsBadVtxFalse, - kIsRecGoodAllTrue, - kIsRecGoodAllFalse, - kIsRecGoodMatchAllTrue, - kIsRecGoodMatchAllFalse, - kIsRecGoodVsGoodVtxTrue, - kIsRecGoodVsGoodVtxFalse, - kIsRecGoodMatchVsGoodVtxTrue, - kIsRecGoodMatchVsGoodVtxFalse, - kIsRecGoodVsBadVtxTrue, - kIsRecGoodVsBadVtxFalse, - kIsRecGoodMatchVsBadVtxTrue, - kIsRecGoodMatchVsBadVtxFalse, - nReassocVtxType +enum class EvtLossType { + kGenAll = 0, + kGenSel, + kGenSplit, + kGenRecEvt, + nEvtLossType }; -enum class ReAssocMCEventStatus { - kEvtReAsAll = 0, - kEvtReAsSelected, - kEvtReAsHasMcColl, - kEvtReAsSplitVtxRemoved, - kEvtReAsZVtxCutMC, - nEvtReAsReAssocMCEventStatus +enum class McEffStatus { + kMcEffAll = 0, + kMcEffSel, + kMcEffHasMcColl, + kMcEffNoSplitVtx, + nMcEfftStatus }; -enum class ReAssocMCTrackStatus { - kTrkReAssocAll = 0, - kTrkBestSel, - kTrkSel, - kTrkHasColl, - kTrkReassignedRemoved, - kTrkHasMcPart, - kTrkIdGt0, - kTrkNonAmb, - kTrkNonAmbGood, - kTrkNonAmbBad, - kTrkNonAmbID, - kTrkNonAmbIDGood, - kTrkNonAmbIDBad, - kTrkAmbID, - kTrkAmbIDGood, - kTrkAmbIDBad, - kTrkNonAmbIDExtra, - kTrkNonAmbIDExtraGood, - kTrkNonAmbIDExtraBad, - kReAssoc, - kReAssocGood, - kReAssocGoodIsCompTrue, - kReAssocGoodIsCompFalse, - kReAssocBad, - kReAssocBadIsCompTrue, - kReAssocBadIsCompFalse, - kAssoc, - kAssocGood, - kAssocGoodIsCompTrue, - kAssocGoodIsCompFalse, - kAssocBad, - kAssocBadIsCompTrue, - kAssocBadIsCompFalse, - nReAssocMCTrackStatusCheck +enum class McStatus { + kMcRecAll = 0, + kMcRecSel, + kMcRecHasMcColl, + kMcRecNoSplitVtx, + kMcGenAll, + nMcStatus }; -enum class HistStatusReAssocVtx { - kTrkRec = 0, - kTrkIdGt0, - kTrkNonAmb, - kTrkNonAmbGood, - kTrkNonAmbBad, - kTrkNonAmbID, - kTrkNonAmbIDGood, - kTrkNonAmbIDBad, - kTrkAmbID, - kTrkAmbIDGood, - kTrkAmbIDBad, - kTrkNonAmbIDExtra, - kTrkNonAmbIDExtraGood, - kTrkNonAmbIDExtraBad, - kReAssoc, - kReAssocGood, - kReAssocGoodIsCompTrue, - kReAssocGoodIsCompFalse, - kReAssocBad, - kReAssocBadIsCompTrue, - kReAssocBadIsCompFalse, - kAssoc, - kAssocGood, - kAssocGoodIsCompTrue, - kAssocGoodIsCompFalse, - kAssocBad, - kAssocBadIsCompTrue, - kAssocBadIsCompFalse, - nHistStatusReAssocVtx +enum class McTrackStatus { + kBestTrkAll = 0, + kBesTrktSel, + kTrkAsBestSel, + kTrkHasColl, + kTrkReassignedRemoved, + nMcTrackStatus }; struct DndetaMFTPbPb { SliceCache cache; - std::array, 4> hCollAssoc; - std::array, 28> hReAssocVtxRes; - std::array, 28> hReAssocDCA; - std::array, 21> hTimeAssocWithReassocMC; - enum OccupancyEst { TrkITS = 1, Ft0C }; - HistogramRegistry registry{ - "registry", - {}, - OutputObjHandlingPolicy::AnalysisObject}; - HistogramRegistry qaregistry{ - "qaregistry", - {}, - OutputObjHandlingPolicy::AnalysisObject, - false, - true}; - - HistogramRegistry registryAlign{"registryAlign", {}}; - std::array mftQuadrant = {"Q0", "Q1", "Q2", "Q3"}; - std::array, 3>, 4>, 2> hAlignment; + HistogramRegistry registryData{"registryData", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryMC{"registryMC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; + HistogramRegistry registryQC{"registryQC", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; struct : ConfigurableGroup { Configurable cfgDoIR{"cfgDoIR", false, "Flag to retrieve Interaction rate from CCDB"}; @@ -340,16 +214,11 @@ struct DndetaMFTPbPb { Configurable cfgUseParticleSel{"cfgUseParticleSel", true, "Flag to apply particle selection"}; Configurable cfgUsePrimaries{"cfgUsePrimaries", true, "Select primary particles"}; Configurable cfgUseSecondaries{"cfgUseSecondaries", false, "Select secondary particles"}; - Configurable cfgRemoveTrivialAssoc{"cfgRemoveTrivialAssoc", false, "Skip trivial associations"}; - Configurable cfgRemoveAmbiguousTracks{"cfgRemoveAmbiguousTracks", false, "Remove ambiguous tracks"}; - Configurable cfgRemoveOrphanTracks{"cfgRemoveOrphanTracks", true, "Remove orphan tracks"}; Configurable cfgRemoveReassigned{"cfgRemoveReassigned", false, "Remove reassgined tracks"}; Configurable cfgRemoveSplitVertex{"cfgRemoveSplitVertex", true, "Remove split vertices"}; Configurable cfgUseTrackParExtra{"cfgUseTrackParExtra", false, "Use table with refitted track parameters"}; - Configurable cfgUseInelgt0{"cfgUseInelgt0", false, "Use INEL > 0 condition"}; Configurable cfgUseInelgt0wMFT{"cfgUseInelgt0wMFT", false, "Use INEL > 0 condition with MFT acceptance"}; Configurable grpmagPath{"grpmagPath", "GLO/Config/GRPMagField", "CCDB path of the GRPMagField object"}; - Configurable cfgDCAtype{"cfgDCAtype", 2, "DCA coordinate type [0: DCA-X, 1: DCA-Y, 2: DCA-XY]"}; } gConf; struct : ConfigurableGroup { @@ -392,8 +261,6 @@ struct DndetaMFTPbPb { Configurable maxPhi{"maxPhi", 6.2832, ""}; Configurable minEta{"minEta", -3.6f, ""}; Configurable maxEta{"maxEta", -2.5f, ""}; - Configurable minEtaGenMult{"minEtaGenMult", -0.5, "Min eta for generated mid-rapidity multiplicity"}; - Configurable maxEtaGenMult{"maxEtaGenMult", 0.5, "Max eta for generated mid-rapidity multiplicity"}; Configurable minNclusterMft{"minNclusterMft", 5, "minimum number of MFT clusters"}; Configurable useChi2Cut{"useChi2Cut", true, "use track chi2 cut"}; Configurable maxChi2NCl{"maxChi2NCl", 40.0f, "maximum chi2 per MFT clusters"}; @@ -428,15 +295,14 @@ struct DndetaMFTPbPb { Configurable maxOccupancy{"maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; Configurable minIR{"minIR", -1, "minimum IR (kHz) collisions"}; Configurable maxIR{"maxIR", -1, "maximum IR (kHz) collisions"}; + Configurable useInelgt0wTVX{"useInelgt0wTVX", false, "Use INEL > 0 condition with TVX trigger, i.e. FT0A and FT0C acceptance"}; + Configurable useGenMult{"useGenMult", false, "use MultMC for centrality"}; } eventCuts; Service pdg{}; Service ccdb{}; Configurable ccdbNoLaterThan{"ccdbNoLaterThan", std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(), "latest acceptable timestamp of creation for the object"}; Configurable ccdbUrl{"ccdbUrl", "http://alice-ccdb.cern.ch", "url of the ccdb repository"}; - Configurable cfgApplyZShiftFromCCDB{"cfgApplyZShiftFromCCDB", false, "flag to apply z shift from CCDB"}; - Configurable cfgZShiftPath{"cfgZShiftPath", "Users/m/mcoquet/ZShift", "CCDB path for z shift to apply to forward tracks"}; - Configurable cfgManualZShift{"cfgManualZShift", 0.0f, "manual z-shift for propagation of global muon to PV"}; int mRunNumber{-1}; uint64_t mSOR{0}; @@ -449,14 +315,10 @@ struct DndetaMFTPbPb { float bZ = 0; // Magnetic field for MFT std::array centerMFT{0, 0, -61.4}; // Field at center of MFT - float mZShift = 0; // z-vertex shift - o2::parameters::GRPMagField* grpmag = nullptr; std::vector ambiguousTrkIds; std::vector reassignedTrkIds; - std::vector ambiguousTrkIdsMC; - std::vector reassignedTrkIdsMC; /// @brief init function, definition of histograms void init(InitContext&) @@ -480,6 +342,11 @@ struct DndetaMFTPbPb { const AxisSpec nclsAxis = {binOpt.nClBins, "Number of clusters axis"}; const AxisSpec tanLambdaAxis{binOpt.tanLambdaBins, "tan(#lambda)"}; const AxisSpec invQPtAxis{binOpt.invQPtBins, "q/p_{T} (1/GeV)"}; + const AxisSpec genEvtTypeAxis = {static_cast(GenTrkType::nGenTrkType) - 1, +0.5, +static_cast(GenTrkType::nGenTrkType) - 0.5, "", "Gen-Trk Type axis"}; + const AxisSpec recEvtTypeAxis = {static_cast(RecTrkType::nRecTrkType) - 1, +0.5, +static_cast(RecTrkType::nRecTrkType) - 0.5, "", "Rec-Trk Type axis"}; + const AxisSpec genEvtIdxTypeAxis = {static_cast(GenTrkType::nGenTrkType) - 1, +0.5, +static_cast(GenTrkType::nGenTrkType) - 0.5, "", "Gen-Trk Type axis"}; + const AxisSpec recEvtIdxTypeAxis = {static_cast(RecTrkType::nRecTrkType) - 1, +0.5, +static_cast(RecTrkType::nRecTrkType) - 0.5, "", "Rec-Trk Type axis"}; + const AxisSpec evtLossTypeAxis = {static_cast(EvtLossType::nEvtLossType) - 1, +0.5, +static_cast(EvtLossType::nEvtLossType) - 0.5, "", "Evt-loss Type axis"}; rctChecker.init(rctCuts.cfgEvtRCTFlagCheckerLabel, rctCuts.cfgEvtRCTFlagCheckerZDCCheck, rctCuts.cfgEvtRCTFlagCheckerLimitAcceptAsBad); @@ -489,68 +356,38 @@ struct DndetaMFTPbPb { ccdb->setCreatedNotAfter(ccdbNoLaterThan.value); ccdb->setFatalWhenNull(false); - if (static_cast(doprocessDataInclusive) + - static_cast(doprocessDatawBestTracksInclusive) > - 1) { - LOGP(fatal, - "Either processDataInclusive OR " - "processDatawBestTracksInclusive should be enabled!"); - } - if ((static_cast(doprocessDataCentFT0C) + - static_cast(doprocessDatawBestTracksCentFT0C) > - 1) || - (static_cast(doprocessDataCentFT0CVariant1) + - static_cast(doprocessDatawBestTracksCentFT0CVariant1) > - 1) || - (static_cast(doprocessDataCentFT0M) + - static_cast(doprocessDatawBestTracksCentFT0M) > - 1) || - (static_cast(doprocessDataCentNGlobal) + - static_cast(doprocessDatawBestTracksCentNGlobal) > - 1) || - (static_cast(doprocessDataCentMFT) + - static_cast(doprocessDatawBestTracksCentMFT) > - 1)) { - LOGP(fatal, - "Either processDataCent[ESTIMATOR] OR " - "processDatawBestTracksCent[ESTIMATOR] should " - "be enabled!"); - } - if (static_cast(doprocessMCInclusive) + - static_cast(doprocessMCwBestTracksInclusive) > - 1) { - LOGP(fatal, - "Either processMCInclusive OR processMCwBestTracksInclusive " - "should be enabled!"); - } - if ((static_cast(doprocessMCCentFT0C) + - static_cast(doprocessMCwBestTracksCentFT0C) > - 1) || - (static_cast(doprocessMCCentFT0CVariant1) + - static_cast(doprocessMCwBestTracksCentFT0CVariant1) > - 1) || - (static_cast(doprocessMCCentFT0M) + - static_cast(doprocessMCwBestTracksCentFT0M) > - 1) || - (static_cast(doprocessMCCentNGlobal) + - static_cast(doprocessMCwBestTracksCentNGlobal) > - 1) || - (static_cast(doprocessMCCentMFT) + - static_cast(doprocessMCwBestTracksCentMFT) > - 1)) { - LOGP(fatal, - "Either processMCCent[ESTIMATOR] OR " - "processMCwBestTracksCent[ESTIMATOR] should " - "be enabled!"); - } - - // registry.add("Events/hRCTSel", "Event accepted if RCT not selected;RCT Status;", {HistType::kTH1F, {{2, 0.5, 2.5}}}); - // auto hrctSel = registry.get(HIST("Events/hRCTSel")); - // auto* x = hrctSel->GetXaxis(); - // x->SetBinLabel(1, "All"); - // x->SetBinLabel(2, "kFT0Bad"); - - registry.add("Events/hEvtSel", "Number of events; Cut; #Evt Passed Cut", {HistType::kTH1F, {{static_cast(EvtSel::nEvtSel), -0.5, +static_cast(EvtSel::nEvtSel) - 0.5}}}); + if (static_cast(doprocessDataInclusive) + static_cast(doprocessDatawBestTracksInclusive) > 1) { + LOGP(fatal, "Either processDataInclusive OR processDatawBestTracksInclusive should be enabled!"); + } + if (static_cast(doprocessDataCentFT0C) + static_cast(doprocessDatawBestTracksCentFT0C) > 1) { + LOGP(fatal, "Either processDataCent[ESTIMATOR] OR processDatawBestTracksCent[ESTIMATOR] should be enabled!"); + } + if (static_cast(doprocessMCInclusive) + static_cast(doprocessMCbestInclusive) > 1) { + LOGP(fatal, "Either processMCInclusive OR processMCbestInclusive should be enabled!"); + } + if (static_cast(doprocessMCCentFT0C) + static_cast(doprocessMCbestCentFT0C) > 1) { + LOGP(fatal, "Either processMCCent[ESTIMATOR] OR processMCbestCent[ESTIMATOR] should be enabled!"); + } + if (static_cast(doprocessEfficiencyInclusive) + static_cast(doprocessEfficiencyBestInclusive) > 1) { + LOGP(fatal, "Either doprocessEfficiencyInclusive OR doprocessEfficiencyBestInclusive should be enabled!"); + } + if (static_cast(doprocessEfficiencyCentFT0C) + static_cast(doprocessEfficiencyBestCentFT0C) > 1) { + LOGP(fatal, "Either doprocessEfficiencyCentFT0C OR doprocessEfficiencyBestCentFT0C should be enabled!"); + } + if (static_cast(doprocessEfficiencyIdxInlusive) + static_cast(doprocessEfficiencyIdxBestInlusive) > 1) { + LOGP(fatal, "Either doprocessEfficiencyIdxInlusive OR doprocessEfficiencyIdxBestInlusive should be enabled!"); + } + if (static_cast(doprocessEfficiencyIdxCentFT0C) + static_cast(doprocessEfficiencyIdxBestCentFT0C) > 1) { + LOGP(fatal, "Either doprocessEfficiencyIdxCentFT0C OR doprocessEfficiencyIdxBestCentFT0C should be enabled!"); + } + + // General counters - QC + auto hBcSel = registryQC.add("hBcSel", "hBcSel", HistType::kTH1F, {{3, -0.5f, +2.5f}}); + hBcSel->GetXaxis()->SetBinLabel(1, "Good BCs"); + hBcSel->GetXaxis()->SetBinLabel(2, "BCs with collisions"); + hBcSel->GetXaxis()->SetBinLabel(3, "BCs with pile-up/splitting"); + + registryQC.add("Events/hEvtSel", "Number of events; Cut; #Evt Passed Cut", {HistType::kTH1F, {{static_cast(EvtSel::nEvtSel), -0.5, +static_cast(EvtSel::nEvtSel) - 0.5}}}); std::array(EvtSel::nEvtSel)> labelEvtSel{ "All coll.", "Sel 8", @@ -568,30 +405,12 @@ struct DndetaMFTPbPb { "Above max occup.", "RCT Flag Checker", "RCT Flag Checker Extra"}; - registry.get(HIST("Events/hEvtSel"))->SetMinimum(0.1); + registryQC.get(HIST("Events/hEvtSel"))->SetMinimum(0.1); for (int iBin = 0; iBin < static_cast(EvtSel::nEvtSel); iBin++) { - registry.get(HIST("Events/hEvtSel"))->GetXaxis()->SetBinLabel(iBin + 1, labelEvtSel[iBin].data()); - } - - qaregistry.add("Events/hCentBest", "; centrality", HistType::kTH1F, {centralityAxis}); - qaregistry.add("Events/hGenMult", "Sel rec evt. vs generated mult; mult", HistType::kTH1F, {multAxis}); - qaregistry.add("Events/hCentRecVsGenMult", "Rec cent vs gen mid-rapidity multiplicity; centrality; mult", HistType::kTH2F, {centralityAxis, multAxis}); - qaregistry.add("Events/hCentRecFromGenMult", "Centrality from generated mult", HistType::kTH1F, {centralityAxis}); - - registry.add("Tracks/hBestTrkSel", "Number of best tracks; Cut; #Tracks Passed Cut", {HistType::kTH1F, {{static_cast(TrkTrkBestSel::nTrkTrkBestSel), -0.5, +static_cast(TrkTrkBestSel::nTrkTrkBestSel) - 0.5}}}); - std::array(TrkTrkBestSel::nTrkTrkBestSel)> labelTrkTrkBestSel{ - "All", - "Assigned (ID>=0)", - "No orphans", - "DCA xy cut", - "DCA z cut", - "#Reassoc"}; - registry.get(HIST("Tracks/hBestTrkSel"))->SetMinimum(0.1); - for (int iBin = 0; iBin < static_cast(TrkTrkBestSel::nTrkTrkBestSel); iBin++) { - registry.get(HIST("Tracks/hBestTrkSel"))->GetXaxis()->SetBinLabel(iBin + 1, labelTrkTrkBestSel[iBin].data()); + registryQC.get(HIST("Events/hEvtSel"))->GetXaxis()->SetBinLabel(iBin + 1, labelEvtSel[iBin].data()); } - registry.add("Tracks/hTrkSel", "Number of tracks; Cut; #Tracks Passed Cut", {HistType::kTH1F, {{static_cast(TrkSel::nTrkSel), -0.5, +static_cast(TrkSel::nTrkSel) - 0.5}}}); + registryQC.add("Tracks/hTrkSel", "Number of tracks; Cut; #Tracks Passed Cut", {HistType::kTH1F, {{static_cast(TrkSel::nTrkSel), -0.5, +static_cast(TrkSel::nTrkSel) - 0.5}}}); std::array(TrkSel::nTrkSel)> labelTrkSel{ "All", "Ncls", @@ -600,693 +419,256 @@ struct DndetaMFTPbPb { "Phi cut", "Pt", "CA"}; - registry.get(HIST("Tracks/hTrkSel"))->SetMinimum(0.1); + registryQC.get(HIST("Tracks/hTrkSel"))->SetMinimum(0.1); for (int iBin = 0; iBin < static_cast(TrkSel::nTrkSel); iBin++) { - registry.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(iBin + 1, labelTrkSel[iBin].data()); - } - - auto hBcSel = registry.add("hBcSel", "hBcSel", HistType::kTH1F, - {{3, -0.5f, +2.5f}}); - hBcSel->GetXaxis()->SetBinLabel(1, "Good BCs"); - hBcSel->GetXaxis()->SetBinLabel(2, "BCs with collisions"); - hBcSel->GetXaxis()->SetBinLabel(3, "BCs with pile-up/splitting"); - - if (doprocessDataInclusive || doprocessDatawBestTracksInclusive || - doprocessMCInclusive || doprocessMCwBestTracksInclusive) { - registry.add({"Events/Selection", - ";status;occupancy", - {HistType::kTH2F, {{2, 0.5, 2.5}, occupancyAxis}}}); - auto hstat = registry.get(HIST("Events/Selection")); + registryQC.get(HIST("Tracks/hTrkSel"))->GetXaxis()->SetBinLabel(iBin + 1, labelTrkSel[iBin].data()); + } + + if (doprocessDatawBestTracksInclusive || doprocessDatawBestTracksCentFT0C || + doprocessMCbestInclusive || doprocessMCbestCentFT0C || + doprocessEfficiencyBestInclusive || doprocessEfficiencyBestCentFT0C || + doprocessEfficiencyIdxBestInlusive || doprocessEfficiencyIdxBestCentFT0C) { + registryQC.add("Tracks/hBestTrkSel", "Number of best tracks; Cut; #Tracks Passed Cut", {HistType::kTH1F, {{static_cast(TrkBestSel::nTrkBestSel), -0.5, +static_cast(TrkBestSel::nTrkBestSel) - 0.5}}}); + std::array(TrkBestSel::nTrkBestSel)> labelTrkTrkBestSel{ + "All", + "Assigned (ID>=0)", + "No orphans", + "DCA xy cut", + "DCA z cut", + "#Reassoc"}; + registryQC.get(HIST("Tracks/hBestTrkSel"))->SetMinimum(0.1); + for (int iBin = 0; iBin < static_cast(TrkBestSel::nTrkBestSel); iBin++) { + registryQC.get(HIST("Tracks/hBestTrkSel"))->GetXaxis()->SetBinLabel(iBin + 1, labelTrkTrkBestSel[iBin].data()); + } + } + if (doprocessDataInclusive || doprocessDatawBestTracksInclusive) { + registryData.add({"Events/hInteractionRate", "; IR (kHz); occupancy", {HistType::kTH2F, {irAxis, occupancyAxis}}}); + registryData.add({"Events/Selection", ";status; occupancy", {HistType::kTH2F, {{2, 0.5, 2.5}, occupancyAxis}}}); + auto hstat = registryData.get(HIST("Events/Selection")); auto* x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); - registry.add("Events/hInteractionRate", "; occupancy; IR (kHz)", kTH2F, {occupancyAxis, irAxis}); - - registry.add({"Events/NtrkZvtx", - "; N_{trk}; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {multAxis, zAxis, occupancyAxis}}}); - registry.add({"Tracks/EtaZvtx", - "; #eta; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); - registry.add( - {"Tracks/PhiEta", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); - - qaregistry.add( - {"Tracks/Chi2Eta", - "; #chi^{2}; #it{#eta}; occupancy", - {HistType::kTHnSparseF, {chiSqAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Chi2", - "; #chi^{2};", - {HistType::kTH2F, {chiSqAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/NclustersEta", - "; nClusters; #eta; occupancy", - {HistType::kTHnSparseF, {nclsAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/NchSel", - "; N_{ch}; occupancy", - {HistType::kTH2F, {multAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/NchBestSel", - "; N_{ch}; occupancy", - {HistType::kTH2F, {multAxis, occupancyAxis}}}); - - qaregistry.add({"Tracks/TanLambda", "; TanLambda; centrality; occupancy", {HistType::kTH2F, {tanLambdaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/InvQPt", "; InvQPt; centrality; occupancy", {HistType::kTH2F, {invQPtAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Eta", "; #eta; centrality; occupancy", {HistType::kTH2F, {etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Phi", "; #varphi; centrality; occupancy", {HistType::kTH2F, {phiAxis, occupancyAxis}}}); + registryData.add({"Tracks/EtaZvtx", "; #eta; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); + registryData.add({"Tracks/PhiEta", "; #varphi; #eta; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); + registryData.add({"Events/NtrkZvtx", "; N_{trk}; Z_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {multAxis, zAxis, occupancyAxis}}}); + registryData.add({"Tracks/Chi2Eta", "; #chi^{2}; #eta; occupancy", {HistType::kTHnSparseF, {chiSqAxis, etaAxis, occupancyAxis}}}); + registryData.add({"Tracks/NclustersEta", "; nClusters; #eta; occupancy", {HistType::kTHnSparseF, {nclsAxis, etaAxis, occupancyAxis}}}); + registryData.add({"Tracks/TanLambda", "; TanLambda; occupancy", {HistType::kTH2F, {tanLambdaAxis, occupancyAxis}}}); + registryData.add({"Tracks/InvQPt", "; InvQPt; occupancy", {HistType::kTH2F, {invQPtAxis, occupancyAxis}}}); if (doprocessDatawBestTracksInclusive) { - registry.add( - {"Events/NtrkZvtxBest", - "; N_{trk}; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {multAxis, zAxis, occupancyAxis}}}); - registry.add( - {"Tracks/EtaZvtxBest", - "; #eta; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); - registry.add( - {"Tracks/PhiEtaBest", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/NclustersEtaBest", - "; nClusters; #eta; occupancy", - {HistType::kTHnSparseF, {nclsAxis, etaAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/DCA3d", - "; p_{T} (GeV/c); #eta; DCA_{XY} (cm); DCA_{Z} (cm); occupancy", - {HistType::kTHnSparseF, {ptAxis, etaAxis, dcaxyAxis, dcazAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/ReTracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/ReTracksPhiEta", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/OrigTracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/OrigTracksPhiEta", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/RestTracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/RestTracksPhiEta", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/TrackAmbDegree", - "; N_{coll}^{comp}; occupancy", - {HistType::kTH2F, {{51, -0.5, 50.5}, occupancyAxis}}}); - qaregistry.add({"Tracks/TanLambdaExtra", "; TanLambda; occupancy", {HistType::kTH2F, {tanLambdaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/InvQPtExtra", "; InvQPt; occupancy", {HistType::kTH2F, {invQPtAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/EtaExtra", "; #eta; occupancy", {HistType::kTH2F, {etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/PhiExtra", "; #varphi; occupancy", {HistType::kTH2F, {phiAxis, occupancyAxis}}}); - } - } - - if (doprocessDataCentFT0C || doprocessDatawBestTracksCentFT0C || - doprocessMCCentFT0C || doprocessMCwBestTracksCentFT0C || - doprocessDataCentFT0CVariant1 || - doprocessDatawBestTracksCentFT0CVariant1 || - doprocessMCCentFT0CVariant1 || doprocessMCwBestTracksCentFT0CVariant1 || - doprocessDataCentFT0M || doprocessDatawBestTracksCentFT0M || - doprocessMCCentFT0M || doprocessMCwBestTracksCentFT0M || - doprocessDataCentNGlobal || doprocessDatawBestTracksCentNGlobal || - doprocessMCCentNGlobal || doprocessMCwBestTracksCentNGlobal || - doprocessDataCentMFT || doprocessDatawBestTracksCentMFT || - doprocessMCCentMFT || doprocessMCwBestTracksCentMFT) { - registry.add({"Events/Centrality/Selection", - ";status;centrality;occupancy", - {HistType::kTHnSparseF, - {{2, 0.5, 2.5}, centralityAxis, occupancyAxis}}}); - auto hstat = registry.get(HIST("Events/Centrality/Selection")); - hstat->GetAxis(0)->SetBinLabel(1, "All"); - hstat->GetAxis(0)->SetBinLabel(2, "Selected"); - - registry.add("Events/Centrality/hInteractionRate", "; centrality; occupancy; IR (kHz)", kTHnSparseF, {centralityAxis, occupancyAxis, irAxis}); - - qaregistry.add({"Events/Centrality/hCent", - "; centrality; occupancy", - {HistType::kTH2F, {centralityAxis, occupancyAxis}}, - true}); - qaregistry.add( - {"Events/Centrality/hZvtxCent", - "; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, {zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Events/Centrality/NtrkZvtx", - "; N_{trk}; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {multAxis, zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtx", - "; #eta; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Tracks/Centrality/PhiEta", - "; #varphi; #eta; centrality; occupancy", - {HistType::kTHnSparseF, - {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); - - qaregistry.add( - {"Tracks/Centrality/NchSel", - "; N_{ch}; centrality; occupancy", - {HistType::kTHnSparseF, {multAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/NchBestSel", - "; N_{ch}; centrality; occupancy", - {HistType::kTHnSparseF, {multAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/Chi2Eta", - "; #chi^{2}; #it{#eta}; centrality; occupancy", - {HistType::kTHnSparseF, - {chiSqAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/Chi2", - "; #chi^{2}; centrality; occupancy", - {HistType::kTHnSparseF, - {chiSqAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/NclustersEta", - "; nClusters; #eta; centrality; occupancy", - {HistType::kTHnSparseF, - {nclsAxis, etaAxis, centralityAxis, occupancyAxis}}}); - - qaregistry.add({"Tracks/Centrality/TanLambda", "; TanLambda; centrality; occupancy", {HistType::kTHnSparseF, {tanLambdaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/InvQPt", "; InvQPt; centrality; occupancy", {HistType::kTHnSparseF, {invQPtAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/Eta", "; #eta; centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/Phi", "; #varphi; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, centralityAxis, occupancyAxis}}}); - - if (doprocessDatawBestTracksCentFT0C || - doprocessDatawBestTracksCentFT0CVariant1 || - doprocessDatawBestTracksCentFT0M || - doprocessDatawBestTracksCentNGlobal || - doprocessDatawBestTracksCentMFT) { - registry.add({"Events/Centrality/NtrkZvtxBest", - "; N_{trk}; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {multAxis, zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtxBest", - "; #eta; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Tracks/Centrality/PhiEtaBest", - "; #varphi; #eta; centrality; occupancy", - {HistType::kTHnSparseF, - {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/NclustersEtaBest", - "; nClusters; #eta; centrality; occupancy", - {HistType::kTHnSparseF, - {nclsAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/TrackAmbDegree", - "; N_{coll}^{comp}; centrality; occupancy", - {HistType::kTHnSparseF, - {{51, -0.5, 50.5}, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/TanLambdaExtra", "; TanLambda; centrality; occupancy", {HistType::kTHnSparseF, {tanLambdaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/InvQPtExtra", "; InvQPt; centrality; occupancy", {HistType::kTHnSparseF, {invQPtAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/EtaExtra", "; #eta; centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/PhiExtra", "; #varphi; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/DCA3d", - "; p_{T} (GeV/c); #eta; DCA_{XY} (cm); DCA_{Z} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, dcaxyAxis, dcazAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/ReTracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, - {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/ReTracksPhiEta", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, - {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/OrigTracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, - {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/OrigTracksPhiEta", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, - {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/RestTracksEtaZvtx", - "; #eta; #it{z}_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, - {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/RestTracksPhiEta", - "; #varphi; #eta; occupancy", - {HistType::kTHnSparseF, - {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); - } - } - - if (doprocessMCInclusive || doprocessMCwBestTracksInclusive) { - registry.add({"Events/EvtEffGen", - ";status;occupancy", - {HistType::kTH2F, {{3, 0.5, 3.5}, occupancyAxis}}}); - auto heff = registry.get(HIST("Events/EvtEffGen")); - auto* h = heff->GetXaxis(); - h->SetBinLabel(1, "All reconstructed"); - h->SetBinLabel(2, "Selected reconstructed"); - h->SetBinLabel(3, "All generated"); - - registry.add({"Events/NtrkZvtxGen_t", - "; N_{trk}; Z_{vtx} (cm);", - {HistType::kTH2F, {multAxis, zAxis}}}); - registry.add({"Events/NtrkZvtxGen", - "; N_{trk}; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {multAxis, zAxis, occupancyAxis}}}); - registry.add({"Tracks/EtaZvtxGen", - "; #eta; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); - registry.add( - {"Tracks/PhiEtaGen", - "; #varphi; #eta;", - {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); - registry.add({"Tracks/EtaZvtxGen_t", - "; #eta; Z_{vtx} (cm);", - {HistType::kTH2F, {etaAxis, zAxis}}}); - registry.add({"Tracks/PhiEtaGen_t", - "; #varphi; #eta;", - {HistType::kTH2F, {phiAxis, etaAxis}}}); - qaregistry.add({"Events/NotFoundEventZvtx", - "; #it{z}_{vtx} (cm)", - {HistType::kTH1F, {zAxis}}}); - qaregistry.add({"Events/ZvtxDiff", - "; Z_{rec} - Z_{gen} (cm)", - {HistType::kTH1F, {deltaZAxis}}}); - qaregistry.add({"Events/SplitMult", - "; N_{gen}; #it{z}_{vtx} (cm)", - {HistType::kTH2F, {multAxis, zAxis}}}); - } - - if (doprocessMCCentFT0C || doprocessMCwBestTracksCentFT0C || - doprocessMCCentFT0CVariant1 || doprocessMCwBestTracksCentFT0CVariant1 || - doprocessMCCentFT0M || doprocessMCwBestTracksCentFT0M || - doprocessMCCentNGlobal || doprocessMCwBestTracksCentNGlobal || - doprocessMCCentMFT || doprocessMCwBestTracksCentMFT) { - registry.add({"Events/Centrality/EvtEffGen", - ";status;centrality;occupancy", - {HistType::kTHnSparseF, - {{3, 0.5, 3.5}, centralityAxis, occupancyAxis}}}); - auto heff = registry.get(HIST("Events/Centrality/EvtEffGen")); - heff->GetAxis(0)->SetBinLabel(1, "All reconstructed"); - heff->GetAxis(0)->SetBinLabel(2, "Selected reconstructed"); - heff->GetAxis(0)->SetBinLabel(3, "All generated"); - - registry.add( - {"Events/Centrality/NtrkZvtxGen_t", - "; N_{trk}; Z_{vtx} (cm); centrality", - {HistType::kTHnSparseF, {multAxis, zAxis, centralityAxis}}}); - registry.add({"Events/Centrality/NtrkZvtxGen", - "; N_{trk}; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {multAxis, zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Events/Centrality/hRecCent", - "; centrality; occupancy", - {HistType::kTH2F, {centralityAxis, occupancyAxis}}}); - registry.add( - {"Events/Centrality/hRecZvtxCent", - "; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, {zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtxGen", - "; #eta; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Tracks/Centrality/PhiEtaGen", - "; #varphi; #eta; centrality; occupancy", - {HistType::kTHnSparseF, - {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); - registry.add({"Tracks/Centrality/EtaZvtxGen_t", - "; #eta; Z_{vtx} (cm); centrality", - {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis}}}); - registry.add( - {"Tracks/Centrality/PhiEtaGen_t", - "; #varphi; #eta; centrality", - {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis}}}); - qaregistry.add({"Events/Centrality/NotFoundEventZvtx", - "; #it{z}_{vtx} (cm); centrality", - {HistType::kTH2F, {zAxis, centralityAxis}}}); - qaregistry.add({"Events/Centrality/ZvtxDiff", - "; Z_{rec} - Z_{gen} (cm); centrality", - {HistType::kTH2F, {deltaZAxis, centralityAxis}}}); - qaregistry.add( - {"Events/Centrality/SplitMult", - "; N_{gen}; #it{z}_{vtx} (cm); centrality", - {HistType::kTHnSparseF, {multAxis, zAxis, centralityAxis}}}); - } - - if (doprocessTrkEffIdxBestInlusive) { - qaregistry.add({"Tracks/hPtEtaEffGenFakeBest", - "; p_{T} (GeV/c); #eta", - {HistType::kTH2F, - {ptAxis, etaAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffGenBest", - "; p_{T} (GeV/c); #eta", - {HistType::kTH2F, - {ptAxis, etaAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffPrimBest", - "; p_{T} (GeV/c); #eta", - {HistType::kTH2F, - {ptAxis, etaAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffSecBest", - "; p_{T} (GeV/c); #eta", - {HistType::kTH2F, - {ptAxis, etaAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffGenDuplBest", - "; p_{T} (GeV/c); #eta", - {HistType::kTH2F, - {ptAxis, etaAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffDuplBest", - "; p_{T} (GeV/c); #eta", - {HistType::kTH2F, - {ptAxis, etaAxis}}}); - qaregistry.add({"Tracks/NmftTrkPerPartBest", - "; #it{N}_{mft tracks per particle}", - {HistType::kTH1F, {multAxis}}}); - } - - if (doprocessTrkEffIdxBestCentFT0C) { - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffGenFakeBest", - "; p_{T} (GeV/c); #eta; centrality", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffGenBest", - "; p_{T} (GeV/c); #eta; centrality", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffPrimBest", - "; p_{T} (GeV/c); #eta; centrality", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffSecBest", - "; p_{T} (GeV/c); #eta; Z_{vtx} (cm)", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffGenDuplBest", - "; p_{T} (GeV/c); #eta; centrality", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffDuplBest", - "; p_{T} (GeV/c); #eta; centrality", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis}}}); - qaregistry.add( - {"Tracks/Centrality/NmftTrkPerPartBest", - "; #it{N}_{mft tracks per particle}; centrality", - {HistType::kTHnSparseF, {multAxis, centralityAxis}}}); - } - - if (doprocessTrkEffIdxInlusive) { - qaregistry.add({"Tracks/hPtEtaEffGen", - "; p_{T} (GeV/c); #eta; occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffPrim", - "; p_{T} (GeV/c); #eta; occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffSec", - "; p_{T} (GeV/c); #eta; occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffGenDupl", - "; p_{T} (GeV/c); #eta; occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/hPtEtaEffDupl", - "; p_{T} (GeV/c); #eta; occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/NmftTrkPerPart", - "; #it{N}_{mft tracks per particle}; occupancy", - {HistType::kTH2F, {multAxis, occupancyAxis}}}); - } - - if (doprocessTrkEffIdxCentFT0C) { - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffGen", - "; p_{T} (GeV/c); #eta; centrality; " - "occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffPrim", - "; p_{T} (GeV/c); #eta; centrality; " - "occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffSec", - "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); centrality; " - "occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffGenDupl", - "; p_{T} (GeV/c); #eta; centrality; " - "occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEtaEffDupl", - "; p_{T} (GeV/c); #eta; centrality; " - "occupancy", - {HistType::kTHnSparseF, - {ptAxis, etaAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/NmftTrkPerPart", - "; #it{N}_{mft tracks per particle}; centrality; occupancy", - {HistType::kTHnSparseF, {multAxis, centralityAxis, occupancyAxis}}}); - } - - if (doprocessTrkEffBestInclusive) { - qaregistry.add({"Tracks/hPtPhiEtaZvtxEffBestGen", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/hPtPhiEtaZvtxEffBestRec", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/hPtEffBestFakeRec", - " ; p_{T} (GeV/c); occupancy", - {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis, occupancyAxis}}}); - } - - if (doprocessTrkEffBestCentFT0C) { - qaregistry.add( - {"Tracks/Centrality/hPtPhiEtaZvtxEffBestGen", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); centrality; " - "occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtPhiEtaZvtxEffBestRec", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); centrality; " - "occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hPtEffBestFakeRec", - "; p_{T} (GeV/c); centrality; occupancy", - {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - } - - if (doprocessMcQACentFT0C) { - qaregistry.add( - {"Events/Centrality/hRecPerGenColls", - "; #it{N}_{reco collisions} / #it{N}_{gen collisions}; centrality", - {HistType::kTHnSparseF, - {{200, 0., 2.}, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/hNmftTrks", - "; #it{N}_{mft tracks}; centrality", - {HistType::kTHnSparseF, - {{200, -0.5, 200.}, centralityAxis, occupancyAxis}}}); - qaregistry.add( - {"Tracks/Centrality/hFracAmbiguousMftTrks", - "; #it{N}_{ambiguous tracks} / #it{N}_{tracks}; centrality", - {HistType::kTHnSparseF, - {{100, 0., 1.}, centralityAxis, occupancyAxis}}}); - } - - if (doprocessCheckAmbiguousMftTracks) { - qaregistry.add({"Tracks/hMftTracksAmbDegree", - " ; N_{coll}^{comp}", - {HistType::kTH1F, {{41, -0.5, 40.5}}}}); - qaregistry.add({"Tracks/hMftTracksAmbDegreeWithTrivial", - " ; N_{coll}^{comp}", - {HistType::kTH1F, {{41, -0.5, 40.5}}}}); - - qaregistry.add("Tracks/hAmbTrackType", "hAmbTrackType", {HistType::kTH1F, {{static_cast(AmbTrkType::nAmbTrkType), -0.5, +static_cast(AmbTrkType::nAmbTrkType) - 0.5}}}); - std::array(AmbTrkType::nAmbTrkType)> labelAmbiguity{ - "all", - "orphan", - "orphanNull", - "nonAmb", - "nonAmbSame", - "Amb", - "AmbGt1"}; - qaregistry.get(HIST("Tracks/hAmbTrackType"))->SetMinimum(0.1); - for (int iBin = 0; iBin < static_cast(AmbTrkType::nAmbTrkType); iBin++) { - qaregistry.get(HIST("Tracks/hAmbTrackType"))->GetXaxis()->SetBinLabel(iBin + 1, labelAmbiguity[iBin].data()); - } - } - - if (doprocessEfficiencyInclusive) { - qaregistry.add({"Tracks/hEffRec", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/hEffFake", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, occupancyAxis}}}); - } - - if (doprocessEfficiencyCentFT0C) { - qaregistry.add({"Tracks/Centrality/hEffRec", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - qaregistry.add({"Tracks/Centrality/hEffFake", - "; p_{T} (GeV/c); #varphi; #eta; Z_{vtx} (cm); centrality; occupancy", - {HistType::kTHnSparseF, - {ptAxis, phiAxis, etaAxis, zAxis, centralityAxis, occupancyAxis}}}); - } - - if (doprocessCorrelationwBestTracksInclusive) { - qaregistry.add("Events/hMultMFTvsFT0A", "MultMFT_vs_FT0A", {HistType::kTH2F, {multAxis, multFT0aAxis}}); - qaregistry.add("Events/hMultMFTvsFT0C", "MultMFT_vs_FT0C", {HistType::kTH2F, {multAxis, multFT0cAxis}}); - qaregistry.add("Events/hNPVtracksVsFT0C", "NPVtracks_vs_FT0C", {HistType::kTH2F, {pvAxis, multFT0cAxis}}); - qaregistry.add("Events/hMultMFTvsFV0A", "MultMFT_vs_FV0A", {HistType::kTH2F, {multAxis, multFV0aAxis}}); - qaregistry.add("Events/hNPVtracksVsMultMFT", "NPVtracks_vs_MultMFT", {HistType::kTH2F, {pvAxis, multAxis}}); - } - - if (doprocessAlignmentInclusive) { - for (size_t j = 0; j < mftQuadrant.size(); j++) { - const auto& quadrant = mftQuadrant[j]; - std::string hPath = std::string("Alignment/") + quadrant + "/"; - hAlignment[0][j][0]["DCA_x_vs_z"] = registryAlign.add((hPath + "DCA_x_vs_z").c_str(), std::format("DCA(x) vs. z - {}", quadrant).c_str(), {HistType::kTH2F, {zAxis, dcaxyAxis}}); - hAlignment[0][j][0]["DCA_y_vs_z"] = registryAlign.add((hPath + "DCA_y_vs_z").c_str(), std::format("DCA(y) vs. z - {}", quadrant).c_str(), {HistType::kTH2F, {zAxis, dcaxyAxis}}); - } - } - - if (doprocessEventAndSignalLossCentFT0C) { - auto hNevt = registry.add("Events/Centrality/hNRecCollsSigEvtLoss", "Number of reconstructed MC collisions", HistType::kTH1F, {{1, 0.5, 1.5}}); - hNevt->GetXaxis()->SetBinLabel(1, "Reconstructed collisions"); - - registry.add("Events/Centrality/EvtSigLossStatus", ";status;centrality", {HistType::kTH2F, {{3, 0.5, 3.5}, centralityAxis}}); - auto hstat = registry.get(HIST("Events/Centrality/EvtSigLossStatus")); + registryData.add({"Tracks/DCA3d", "; p_{T} (GeV/c); #eta; DCA_{XY} (cm); DCA_{Z} (cm); occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, dcaxyAxis, dcazAxis, occupancyAxis}}}); + registryData.add({"Tracks/ReTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); + registryData.add({"Tracks/ReTracksPhiEta", "; #varphi; #eta; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); + registryData.add({"Tracks/OrigTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); + registryData.add({"Tracks/OrigTracksPhiEta", "; #varphi; #eta; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); + registryData.add({"Tracks/RestTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); + registryData.add({"Tracks/RestTracksPhiEta", "; #varphi; #eta; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); + registryData.add({"Tracks/TrackAmbDegree", "; N_{coll}^{comp}; occupancy", {HistType::kTH2F, {{51, -0.5, 50.5}, occupancyAxis}}}); + registryData.add({"Tracks/TanLambdaExtra", "; TanLambda; occupancy", {HistType::kTH2F, {tanLambdaAxis, occupancyAxis}}}); + registryData.add({"Tracks/InvQPtExtra", "; InvQPt; occupancy", {HistType::kTH2F, {invQPtAxis, occupancyAxis}}}); + registryData.add({"Tracks/EtaExtra", "; #eta; occupancy", {HistType::kTH2F, {etaAxis, occupancyAxis}}}); + registryData.add({"Tracks/PhiExtra", "; #varphi; occupancy", {HistType::kTH2F, {phiAxis, occupancyAxis}}}); + } + } + if (doprocessDataCentFT0C || doprocessDatawBestTracksCentFT0C) { + registryData.add({"Events/Centrality/hInteractionRate", "; IR (kHz); centrality; occupancy", {HistType::kTHnSparseF, {irAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Events/Centrality/Selection", ";status; centrality; occupancy", {HistType::kTHnSparseF, {{2, 0.5, 2.5}, centralityAxis, occupancyAxis}}}); + auto hstat = registryData.get(HIST("Events/Centrality/Selection")); + hstat->GetXaxis()->SetBinLabel(1, "All"); + hstat->GetXaxis()->SetBinLabel(2, "Selected"); + + registryData.add({"Tracks/Centrality/EtaZvtx", "; #eta; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/PhiEta", "; #varphi; #eta; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Events/Centrality/NtrkZvtx", "; N_{trk}; Z_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {multAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/Chi2Eta", "; #chi^{2}; #eta; centrality; occupancy", {HistType::kTHnSparseF, {chiSqAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/NclustersEta", "; nClusters; #eta; centrality; occupancy", {HistType::kTHnSparseF, {nclsAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/TanLambda", "; TanLambda; centrality; occupancy", {HistType::kTHnSparseF, {tanLambdaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/InvQPt", "; InvQPt; centrality; occupancy", {HistType::kTHnSparseF, {invQPtAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Events/Centrality/hZvtxCent", "; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {zAxis, centralityAxis, occupancyAxis}}}); + + if (doprocessDatawBestTracksCentFT0C) { + registryData.add({"Tracks/Centrality/DCA3d", "; p_{T} (GeV/c); #eta; DCA_{XY} (cm); DCA_{Z} (cm); centrality; occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, dcaxyAxis, dcazAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/ReTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/ReTracksPhiEta", "; #varphi; #eta; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/OrigTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/OrigTracksPhiEta", "; #varphi; #eta; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/RestTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/RestTracksPhiEta", "; #varphi; #eta; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/TrackAmbDegree", "; N_{coll}^{comp}; centrality; occupancy", {HistType::kTHnSparseF, {{51, -0.5, 50.5}, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/TanLambdaExtra", "; TanLambda; centrality; occupancy", {HistType::kTHnSparseF, {tanLambdaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/InvQPtExtra", "; InvQPt; centrality; occupancy", {HistType::kTHnSparseF, {invQPtAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/EtaExtra", "; #eta; centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, centralityAxis, occupancyAxis}}}); + registryData.add({"Tracks/Centrality/PhiExtra", "; #varphi; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, centralityAxis, occupancyAxis}}}); + } + } + if (doprocessMCInclusive || doprocessMCbestInclusive) { + registryMC.add("Events/McStatus", "Number of events; Cut; occupancy", {HistType::kTH2F, {{static_cast(McStatus::nMcStatus), -0.5, +static_cast(McStatus::nMcStatus) - 0.5}, occupancyAxis}}); + std::array(McStatus::nMcStatus)> labelMcStatus{ + "Rec all", + "Rec sel", + "Rec w/ mc coll", + "Rec w/o split vtx", + "Gen all"}; + for (int iBin = 0; iBin < static_cast(McStatus::nMcStatus); iBin++) { + registryMC.get(HIST("Events/McStatus"))->GetXaxis()->SetBinLabel(iBin + 1, labelMcStatus[iBin].data()); + } + if (doprocessMCbestInclusive) { + registryMC.add({"Tracks/hMcTrackStatus", "Number of tracks; Cut; occupancy", {HistType::kTH2F, {{static_cast(McTrackStatus::nMcTrackStatus), -0.5, +static_cast(McTrackStatus::nMcTrackStatus) - 0.5}, occupancyAxis}}}); + std::array(McTrackStatus::nMcTrackStatus)> labelMcTrackStatus{ + "Best all", + "Best sel", + "Trk sel", + "Has coll", + "Reas rm"}; + for (int iBin = 0; iBin < static_cast(McTrackStatus::nMcTrackStatus); iBin++) { + registryMC.get(HIST("Tracks/hMcTrackStatus"))->GetXaxis()->SetBinLabel(iBin + 1, labelMcTrackStatus[iBin].data()); + } + registryMC.add({"Tracks/DCA3d", "; p_{T} (GeV/c); #eta; DCA_{XY} (cm); DCA_{Z} (cm); occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, dcaxyAxis, dcazAxis, occupancyAxis}}}); + registryMC.add({"Tracks/TrackAmbDegree", "; N_{coll}^{comp}; occupancy", {HistType::kTH2F, {{51, -0.5, 50.5}, occupancyAxis}}}); + } + registryMC.add({"Tracks/EtaZvtx", "; #eta; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); + registryMC.add({"Tracks/EtaZvtxGen", "; #eta; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, occupancyAxis}}}); + registryMC.add({"Tracks/PhiEta", "; #varphi; #eta; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); + registryMC.add({"Tracks/PhiEtaGen", "; #varphi; #eta; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, occupancyAxis}}}); + registryMC.add({"Events/NtrkZvtxGen_t", "; N_{trk}; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {multAxis, zAxis, occupancyAxis}}}); + registryMC.add({"Events/NtrkZvtxGen", "; N_{trk}; #it{z}_{vtx} (cm); occupancy", {HistType::kTHnSparseF, {multAxis, zAxis, occupancyAxis}}}); + registryMC.add({"Tracks/NclustersEta", "; nClusters; #eta; occupancy", {HistType::kTHnSparseF, {nclsAxis, etaAxis, occupancyAxis}}}); + registryMC.add({"Events/NotFoundEventZvtx", "; #it{z}_{vtx} (cm); occupancy", {HistType::kTH2F, {zAxis, occupancyAxis}}}); + registryMC.add({"Events/ZvtxDiff", "; Z_{rec} - Z_{gen} (cm); occupancy", {HistType::kTH2F, {deltaZAxis, occupancyAxis}}}); + } + if (doprocessMCCentFT0C || doprocessMCbestCentFT0C) { + registryMC.add("Events/Centrality/McStatus", "Number of events; Cut; centrality; occupancy", {HistType::kTHnSparseF, {{static_cast(McStatus::nMcStatus), -0.5, +static_cast(McStatus::nMcStatus) - 0.5}, centralityAxis, occupancyAxis}}); + std::array(McStatus::nMcStatus)> labelMcStatusCent{ + "Rec all", + "Rec sel", + "Rec w/ mc coll", + "Rec w/o split vtx", + "Gen all"}; + for (int iBin = 0; iBin < static_cast(McStatus::nMcStatus); iBin++) { + registryMC.get(HIST("Events/Centrality/McStatus"))->GetAxis(0)->SetBinLabel(iBin + 1, labelMcStatusCent[iBin].data()); + } + if (doprocessMCbestCentFT0C) { + registryMC.add({"Tracks/Centrality/hMcTrackStatus", "Number of tracks; Cut; centrality; occupancy", {HistType::kTHnSparseF, {{static_cast(McTrackStatus::nMcTrackStatus), -0.5, +static_cast(McTrackStatus::nMcTrackStatus) - 0.5}, centralityAxis, occupancyAxis}}}); + std::array(McTrackStatus::nMcTrackStatus)> labelMcStatusCentBest{ + "Best all", + "Best sel", + "Trk sel", + "Has coll", + "Reas rm"}; + for (int iBin = 0; iBin < static_cast(McTrackStatus::nMcTrackStatus); iBin++) { + registryMC.get(HIST("Tracks/Centrality/hMcTrackStatus"))->GetAxis(0)->SetBinLabel(iBin + 1, labelMcStatusCentBest[iBin].data()); + } + registryMC.add({"Tracks/Centrality/DCA3d", "; p_{T} (GeV/c); #eta; DCA_{XY} (cm); DCA_{Z} (cm); centrality; occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, dcaxyAxis, dcazAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/TrackAmbDegree", "; N_{coll}^{comp}; centrality; occupancy", {HistType::kTHnSparseF, {{51, -0.5, 50.5}, centralityAxis, occupancyAxis}}}); + } + registryMC.add({"Tracks/Centrality/EtaZvtx", "; #eta; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/EtaZvtxGen", "; #eta; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/EtaZvtxGen_t", "; #eta; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {etaAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/PhiEta", "; #varphi; #eta; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/PhiEtaGen", "; #varphi; #eta; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/PhiEtaGen_t", "; #varphi; #eta; centrality; occupancy", {HistType::kTHnSparseF, {phiAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Events/Centrality/NtrkZvtxGen_t", "; N_{trk}; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {multAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Events/Centrality/NtrkZvtxGen", "; N_{trk}; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {multAxis, zAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/NclustersEta", "; nClusters; #eta; centrality; occupancy", {HistType::kTHnSparseF, {nclsAxis, etaAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Events/Centrality/NotFoundEventZvtx", "; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {zAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Events/Centrality/ZvtxDiff", "; Z_{rec} - Z_{gen} (cm); centrality; occupancy", {HistType::kTHnSparseF, {deltaZAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Events/Centrality/hRecZvtxCent", "; #it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {zAxis, centralityAxis, occupancyAxis}}}); + } + if (doprocessEfficiencyInclusive || doprocessEfficiencyBestInclusive) { + registryMC.add("Events/hMcEffStatus", "Number of events; Cut; occupancy", {HistType::kTH2F, {{static_cast(McEffStatus::nMcEfftStatus), -0.5, +static_cast(McEffStatus::nMcEfftStatus) - 0.5}, occupancyAxis}}); + std::array(McEffStatus::nMcEfftStatus)> labelMcEffStatus{ + "All", + "Selected", + "Has Mc Coll", + "Split Vtx Removed"}; + for (int iBin = 0; iBin < static_cast(McEffStatus::nMcEfftStatus); iBin++) { + registryMC.get(HIST("Events/hMcEffStatus"))->GetXaxis()->SetBinLabel(iBin + 1, labelMcEffStatus[iBin].data()); + } + registryMC.add({"Events/hVtxZGen", "; #it{z}_{vtx} (cm); genEvtType; occupancy", {HistType::kTHnSparseF, {zAxis, genEvtTypeAxis, occupancyAxis}}}); + registryMC.add({"Tracks/hEffGen", "; p_{T} (GeV/c); #varphi; #eta; #it{z}_{vtx} (cm); genEvtType; occupancy", {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis, genEvtTypeAxis, occupancyAxis}}}); + registryMC.add({"Events/hVtxZRec", "#it{z}_{vtx} (cm); occupancy", {HistType::kTH2F, {zAxis, occupancyAxis}}}); + registryMC.add({"Tracks/hEffRec", "; p_{T} (GeV/c); #varphi; #eta; #it{z}_{vtx} (cm); recEvtType; occupancy", {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis, recEvtTypeAxis, occupancyAxis}}}); + registryMC.add({"Tracks/hEtaRes", "#eta resolution;;(#eta_{rec} - #eta_{gen})/#eta_{gen}; occupancy", {HistType::kTHnSparseF, {etaAxis, {100, -1.0, 1.0}, occupancyAxis}}}); + } + if (doprocessEfficiencyCentFT0C || doprocessEfficiencyBestCentFT0C) { + registryMC.add("Events/Centrality/hMcEffStatus", "Number of events; Cut; centrality; occupancy", {HistType::kTHnSparseF, {{static_cast(McEffStatus::nMcEfftStatus), -0.5, +static_cast(McEffStatus::nMcEfftStatus) - 0.5}, centralityAxis, occupancyAxis}}); + std::array(McEffStatus::nMcEfftStatus)> labelMcEffStatusCent{ + "All", + "Selected", + "Has Mc Coll", + "Split Vtx Removed"}; + for (int iBin = 0; iBin < static_cast(McEffStatus::nMcEfftStatus); iBin++) { + registryMC.get(HIST("Events/Centrality/hMcEffStatus"))->GetAxis(0)->SetBinLabel(iBin + 1, labelMcEffStatusCent[iBin].data()); + } + registryMC.add({"Events/Centrality/hVtxZGen", "; #it{z}_{vtx} (cm); genEvtType; centrality; occupancy", {HistType::kTHnSparseF, {zAxis, genEvtTypeAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/hEffGen", "; p_{T} (GeV/c); #varphi; #eta; #it{z}_{vtx} (cm); genEvtType; centrality; occupancy", {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis, genEvtTypeAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Events/Centrality/hVtxZRec", "#it{z}_{vtx} (cm); centrality; occupancy", {HistType::kTHnSparseF, {zAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/hEffRec", "; p_{T} (GeV/c); #varphi; #eta; #it{z}_{vtx} (cm); recEvtType; centrality; occupancy", {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis, recEvtTypeAxis, centralityAxis, occupancyAxis}}}); + } + if (doprocessEfficiencyIdxInlusive || doprocessEfficiencyIdxBestInlusive) { + registryMC.add({"Tracks/hEffIdxGen", "; p_{T} (GeV/c); #eta; recEvtIdxType; occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, recEvtIdxTypeAxis, occupancyAxis}}}); + registryMC.add({"Tracks/hEffIdxRec", "; p_{T} (GeV/c); #eta; genEvtIdxType; occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, genEvtIdxTypeAxis, occupancyAxis}}}); + registryMC.add({"Tracks/NmftTrkPerPart", "; #it{N}_{mft tracks per particle}; occupancy", {HistType::kTH2F, {multAxis, occupancyAxis}}}); + } + if (doprocessEfficiencyIdxCentFT0C || doprocessEfficiencyIdxBestCentFT0C) { + registryMC.add({"Tracks/Centrality/hEffIdxGen", "; p_{T} (GeV/c); #eta; recEvtIdxType; centrality; occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, recEvtIdxTypeAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/hEffIdxRec", "; p_{T} (GeV/c); #eta; genEvtIdxType; centrality; occupancy", {HistType::kTHnSparseF, {ptAxis, etaAxis, genEvtIdxTypeAxis, centralityAxis, occupancyAxis}}}); + registryMC.add({"Tracks/Centrality/NmftTrkPerPart", "; #it{N}_{mft tracks per particle}; centrality; occupancy", {HistType::kTH2F, {multAxis, centralityAxis, occupancyAxis}}}); + } + if (doprocessMcSgnEvtLossCentFT0C) { + registryMC.add("Events/hEvtMcGen", "Events/hEvtMcGen", {HistType::kTH1F, {{4, 0.f, 4.f}}}); + registryMC.get(HIST("Events/hEvtMcGen"))->GetXaxis()->SetBinLabel(1, "all"); + registryMC.get(HIST("Events/hEvtMcGen"))->GetXaxis()->SetBinLabel(2, "z-vtx"); + registryMC.get(HIST("Events/hEvtMcGen"))->GetXaxis()->SetBinLabel(3, "isInelGt0wMft"); + registryMC.get(HIST("Events/hEvtMcGen"))->GetXaxis()->SetBinLabel(4, "TVX"); + // + registryMC.add("Events/EvtSigLossStatus", ";status;centrality", {HistType::kTH1F, {{3, 0.5, 3.5}}}); + auto hstat = registryMC.get(HIST("Events/EvtSigLossStatus")); hstat->GetXaxis()->SetBinLabel(1, "All MC gen events"); hstat->GetXaxis()->SetBinLabel(2, "MC gen events with rec event with event selection"); hstat->GetXaxis()->SetBinLabel(3, "MC gen events with no rec events"); - - registry.add("Events/Centrality/hMultGenVsCent", "event mult MC gen", {HistType::kTH2F, {centralityAxis, multFT0cAxis}}); - registry.add("Events/Centrality/hMultGenVsCentNParticlesEta05", "event mult MC gen", {HistType::kTH2F, {centralityAxis, multAxis}}); - registry.add("Events/Centrality/hMultGenVsCentNParticlesEtaMFT", "event mult MC gen", {HistType::kTH2F, {centralityAxis, multAxis}}); - registry.add("Events/Centrality/hMultGenVsCentRec", "event mult MC gen vs centrality", {HistType::kTH2F, {centralityAxis, multFT0cAxis}}); - registry.add("Events/Centrality/hMultGenVsCentRecNParticlesEta05", "event mult MC gen vs centrality", {HistType::kTH2F, {centralityAxis, multAxis}}); - registry.add("Events/Centrality/hMultGenVsCentRecNParticlesEtaMFT", "event mult MC gen vs centrality", {HistType::kTH2F, {centralityAxis, multAxis}}); - registry.add({"Tracks/Centrality/EtaCentVsMultGen_t", "; #eta; centrality; mult gen", {HistType::kTHnSparseF, {etaAxis, centralityAxis, multFT0cAxis}}}); - registry.add({"Tracks/Centrality/EtaCentVsMultGen", "; #eta; centrality; mult gen", {HistType::kTHnSparseF, {etaAxis, centralityAxis, multFT0cAxis}}}); - registry.add({"Tracks/Centrality/EtaGen_t", "; #eta; centrality; occupancy", {HistType::kTH2F, {etaAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/EtaGen", "; #eta; centrality; occupancy", {HistType::kTH2F, {etaAxis, centralityAxis}}}); - } - - if (doprocessDCAReassocMc) { - registry.add({"Events/Centrality/EvtGenRecReassoc", ";status;centrality", {HistType::kTHnSparseF, {{4, 0.5, 4.5}, centralityAxis}}}); - auto heff = registry.get(HIST("Events/Centrality/EvtGenRecReassoc")); - heff->GetAxis(0)->SetBinLabel(1, "All generated"); - heff->GetAxis(0)->SetBinLabel(2, "All reconstructed"); - heff->GetAxis(0)->SetBinLabel(3, "Selected reconstructed"); - heff->GetAxis(0)->SetBinLabel(4, "Remove split vertices"); - - registry.add({"Tracks/Centrality/THnDCAxyBestRec", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestRecFake", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenPrim", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthPrim", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenPrimWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthPrimWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenPrimNonAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthPrimNonAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenPrimNonAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthPrimNonAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenPrimAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthPrimAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenPrimAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthPrimAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSec", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthSec", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthSecWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecNonAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthSecNonAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecNonAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthSecNonAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthSecAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenTruthSecAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecWeak", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecMat", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecWeakNonAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecMatNonAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecWeakAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecWeakAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecMatAmb", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); - registry.add({"Tracks/Centrality/THnDCAxyBestGenSecMatAmbWrongColl", "; p_{T} (GeV/c); #eta; Z_{vtx} (cm); DCA_{XY} (cm); DCA_{Z} (cm)", {HistType::kTHnSparseF, {ptAxis, etaAxis, zAxis, dcaxyAxis, dcazAxis, centralityAxis, centralityAxis}}}); + // + registryMC.add({"Events/hNchGen", "Evt loss; Gen Nch FT0C; evtLossType", {HistType::kTH2F, {multFT0cAxis, evtLossTypeAxis}}}); + registryMC.add({"Events/hMultGenVsCentSplit", "Split MC events: Gen Nch vs Rec Cent; rec cent; Gen Nch ", {HistType::kTH2F, {centralityAxis, multFT0cAxis}}}); + registryMC.add({"Events/hNchTVX", "; Nch; status", {HistType::kTH2F, {{2, 0, 2}, multAxis}}}); + registryMC.add({"Events/hMultGenVsCent", "event mult MC gen", {HistType::kTH2F, {centralityAxis, multFT0cAxis}}}); + registryMC.add({"Events/hMultGenVsCentNParticlesEta05", "event mult MC gen", {HistType::kTH2F, {centralityAxis, multAxis}}}); + registryMC.add({"Events/hMultGenVsCentNParticlesEtaMFT", "event mult MC gen", {HistType::kTH2F, {centralityAxis, multAxis}}}); + registryMC.add({"Events/hMultGenVsCentRec", "event mult MC gen vs centrality", {HistType::kTH2F, {centralityAxis, multFT0cAxis}}}); + registryMC.add({"Events/hMultGenVsCentRecNParticlesEta05", "event mult MC gen vs centrality", {HistType::kTH2F, {centralityAxis, multAxis}}}); + registryMC.add({"Events/hMultGenVsCentRecNParticlesEtaMFT", "event mult MC gen vs centrality", {HistType::kTH2F, {centralityAxis, multAxis}}}); + registryMC.add({"Tracks/hEtaVsNchGen", "; #eta; mult gen", {HistType::kTH2F, {etaAxis, multFT0cAxis}}}); + registryMC.add({"Tracks/hEtaVsNchGenRecEvt", "; #eta; mult gen w/ Rec evt", {HistType::kTH2F, {etaAxis, multFT0cAxis}}}); + } + if (doprocessCorrelationwBestTracksInclusive) { + registryData.add("Events/hMultMFTvsFT0A", "MultMFT_vs_FT0A", {HistType::kTH2F, {multAxis, multFT0aAxis}}); + registryData.add("Events/hMultMFTvsFT0C", "MultMFT_vs_FT0C", {HistType::kTH2F, {multAxis, multFT0cAxis}}); + registryData.add("Events/hNPVtracksVsFT0C", "NPVtracks_vs_FT0C", {HistType::kTH2F, {pvAxis, multFT0cAxis}}); + registryData.add("Events/hMultMFTvsFV0A", "MultMFT_vs_FV0A", {HistType::kTH2F, {multAxis, multFV0aAxis}}); + registryData.add("Events/hNPVtracksVsMultMFT", "NPVtracks_vs_MultMFT", {HistType::kTH2F, {pvAxis, multAxis}}); } } - /// Filters - tracks - Filter filtTrkEta = (aod::fwdtrack::eta < trackCuts.maxEta) && - (aod::fwdtrack::eta > trackCuts.minEta); - Filter filtATrackID = (aod::fwdtrack::bestCollisionId >= CintZero); - Filter filtATrackDCAxy = (nabs(aod::fwdtrack::bestDCAXY) < trackCuts.maxDCAxy); - Filter filtATrackDCAz = (nabs(aod::fwdtrack::bestDCAZ) < trackCuts.maxDCAz); - + /// Filters - particles + Filter primaries = ifnode(nsqrt(aod::mcparticle::vx * aod::mcparticle::vx + aod::mcparticle::vy * aod::mcparticle::vy) > CfloatFive, false, ncheckbit(aod::mcparticle_v2::storedFlags, (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary)); /// Joined tables using FullBCs = soa::Join; using CollBCs = soa::Join; using ExtBCs = soa::Join; - /// Collisions using Colls = soa::Join; using CollsCentFT0C = soa::Join; - using CollsCentFT0CVariant1 = - soa::Join; - using CollsCentFT0M = soa::Join; - using CollsCentNGlobal = - soa::Join; - using CollsCentMFT = soa::Join; - using CollsGenCentFT0C = soa::Join; - using CollsGenCentFT0CExtra = soa::Join; + using CollsGenCentFT0C = soa::Join; using CollsCorr = soa::Join; - using CollsMCExtra = soa::Join; using CollsMCExtraMult = soa::Join; - /// Tracks - using MFTTracksLabeled = soa::Join; - using MftTracksWColls = soa::Join; - using BestTracksMC = soa::Join; - - /// Filtered tables - using FiltMftTracks = soa::Filtered; - using FiltBestTracks = soa::Filtered; - - Preslice perMCCol = aod::mcparticle::mcCollisionId; - PresliceUnsorted perCollMcRec = aod::mccollisionlabel::mcCollisionId; + using MftTracksLabeled = soa::Join; + using MftBestTracksLabeled = soa::Join; + /// Particles + using ParticlesIdx = soa::Join; + using FiltParticlesIdx = soa::Filtered; template float getDCAz(const T& track) @@ -1298,135 +680,21 @@ struct DndetaMFTPbPb { } } - /// \brief RMS calculation - /// \param vec vector of values to compute RMS - template - T computeRMS(std::vector& vec) - { - T sum = std::accumulate(vec.begin(), vec.end(), 0.0); - T mean = sum / vec.size(); - - std::vector diff(vec.size()); - std::transform(vec.begin(), vec.end(), diff.begin(), [mean](T x) { return x - mean; }); - T sqSum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0); - T stdev = std::sqrt(sqSum / vec.size()); - - return stdev; - } - - std::unordered_set mcIds; - std::unordered_set setRecCollSel; - std::unordered_map refCentByMcId; - std::unordered_map genCentByMcId; - std::unordered_map mapMcCollIdPerRecColl; - std::unordered_map mapRecToMc; - std::unordered_map mapMcToRec; - - /// \brief check good rec vertex of corresponding mc coll is available in compatible rec coll - template - bool isRecInCompColl(AT const& atrack) - { - auto const& ids = atrack.compatibleCollIds(); - bool isInCoColl = false; - if (atrack.ambDegree() != 0) { - const int mcCollId = atrack.mcParticle().mcCollisionId(); - if (!ids.empty()) { - for (auto const& id : ids) { - auto itMcCollId = mapMcCollIdPerRecColl.find(id); - if (itMcCollId != mapMcCollIdPerRecColl.end()) { - if (itMcCollId->second == mcCollId) { - isInCoColl = true; - return isInCoColl; - } - } else { - return isInCoColl; - } - } - } - } - return isInCoColl; - } - - template - void createMCIds(MC const& mcCollisions, CollsGenCentFT0CExtra const& collisions, P const& particles) + std::unordered_map mapMcCollIdPerRecColl; + template + void buildLookupTable(C const& collisions) { - const auto& nMcColls = mcCollisions.size(); - LOG(info) << "MC collisions: " << nMcColls; const auto& nRecoColls = collisions.size(); - LOG(info) << "Reconstructed collisions: " << nRecoColls; - - mcIds.clear(); - mcIds.reserve(nMcColls); - setRecCollSel.clear(); - setRecCollSel.reserve(nRecoColls); - refCentByMcId.clear(); - refCentByMcId.reserve(nMcColls); - genCentByMcId.clear(); - genCentByMcId.reserve(nMcColls); mapMcCollIdPerRecColl.clear(); mapMcCollIdPerRecColl.reserve(nRecoColls); - mapRecToMc.clear(); - mapRecToMc.reserve(nRecoColls); - mapMcToRec.clear(); - mapMcToRec.reserve(nRecoColls); - - for (const auto& mcCollision : mcCollisions) { - const auto mcId = mcCollision.globalIndex(); - - if (eventCuts.useZVtxCutMC && (std::abs(mcCollision.posZ()) >= eventCuts.maxZvtx)) { - continue; - } - - bool atLeastOne = false; - int maxNcontributors = -1; - float bestCollCent = CInvalid; - - auto groupedColls = collisions.sliceBy(perCollMcRec, mcId); - for (auto const& collision : groupedColls) { - const float lCent = getRecoCent(collision); - if (!isGoodEvent(collision)) { - continue; - } - if (gConf.cfgUseInelgt0 && !collision.isInelGt0()) { - continue; - } - atLeastOne = true; - - // const int nContrib = collision.multPVTotalContributors(); - const int nContrib = collision.numContrib(); - if (maxNcontributors < nContrib) { - maxNcontributors = nContrib; - bestCollCent = lCent; - mapMcCollIdPerRecColl.emplace(collision.globalIndex(), collision.mcCollisionId()); - mapRecToMc.emplace(collision.globalIndex(), collision.mcCollisionId()); - mapMcToRec.emplace(collision.mcCollisionId(), collision.globalIndex()); - setRecCollSel.insert(collision.globalIndex()); - } - } - - if (!atLeastOne || bestCollCent == CInvalid) { - continue; - } - - auto partsPerMcColl = particles.sliceBy(perMCCol, mcId); - const int genMult = countPartMidRap(partsPerMcColl); - const float genCentClass = getCentGenMult(genMult); - if (genCentClass == CInvalid) { - continue; - } - if (genCentClass < eventCuts.minCentrality || genCentClass > eventCuts.maxCentrality) { - continue; + int maxNcontributors = -1; + for (auto const& collision : collisions) { + // const int nContrib = collision.multPVTotalContributors(); + const int nContrib = collision.numContrib(); + if (maxNcontributors < nContrib) { + maxNcontributors = nContrib; } - - qaregistry.fill(HIST("Events/hCentBest"), bestCollCent); - - mcIds.insert(mcId); - refCentByMcId.emplace(mcId, genCentClass); - genCentByMcId[mcId] = genMult; - - qaregistry.fill(HIST("Events/hGenMult"), genMult); - qaregistry.fill(HIST("Events/hCentRecFromGenMult"), genCentClass); - qaregistry.fill(HIST("Events/hCentRecVsGenMult"), bestCollCent, genMult); + mapMcCollIdPerRecColl.emplace(collision.globalIndex(), collision.mcCollisionId()); } } @@ -1446,45 +714,31 @@ struct DndetaMFTPbPb { auto field = dynamic_cast(TGeoGlobalMagField::Instance()->GetField()); bZ = field->getBz(centerMFT.data()); LOG(info) << "The field at the center of the MFT is bZ = " << bZ; - - if (cfgApplyZShiftFromCCDB) { - auto* zShift = ccdb->getForTimeStamp>(cfgZShiftPath, bc.timestamp()); - if (zShift != nullptr && !zShift->empty()) { - LOGF(info, "reading z shift %f from %s", (*zShift)[0], cfgZShiftPath.value); - mZShift = (*zShift)[0]; - } else { - LOGF(info, "z shift is not found in ccdb path %s. set to 0 cm", cfgZShiftPath.value); - mZShift = 0; - } - } else { - LOGF(info, "z shift is manually set to %f cm", cfgManualZShift.value); - mZShift = cfgManualZShift; - } } template bool isBestTrackSelected(const B& besttrack) { if constexpr (fillHis) { - registry.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkTrkBestSel::trkTrkBestSelAll)); + registryQC.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkBestSel::trkBestSelAll)); } if (besttrack.bestCollisionId() < CintZero) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkTrkBestSel::trkTrkBestSelCollID)); + registryQC.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkBestSel::trkBestSelCollID)); } if (besttrack.ambDegree() == CintZero) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkTrkBestSel::trkTrkBestSelOrphan)); + registryQC.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkBestSel::trkBestSelOrphan)); } if (std::abs(besttrack.bestDCAXY()) >= trackCuts.maxDCAxy) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkTrkBestSel::trkTrkBestSelDCAxyCut)); + registryQC.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkBestSel::trkBestSelDCAxyCut)); } if (trackCuts.useDCAzCut) { const float bestDcaZ = getDCAz(besttrack); @@ -1493,7 +747,7 @@ struct DndetaMFTPbPb { } } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkTrkBestSel::trkTrkBestSelDCAzCut)); + registryQC.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkBestSel::trkBestSelDCAzCut)); } return true; } @@ -1502,13 +756,13 @@ struct DndetaMFTPbPb { bool isTrackSelected(const T& track) { if constexpr (fillHis) { - registry.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelAll)); + registryQC.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelAll)); } if (track.nClusters() < trackCuts.minNclusterMft) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelNCls)); + registryQC.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelNCls)); } if (trackCuts.useChi2Cut) { float nclMft = std::max(2.0f * track.nClusters() - 5.0f, 1.0f); @@ -1518,20 +772,16 @@ struct DndetaMFTPbPb { } } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelChi2Ncl)); + registryQC.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelChi2Ncl)); } if (track.eta() < trackCuts.minEta || track.eta() > trackCuts.maxEta) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelEta)); + registryQC.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelEta)); } if (trackCuts.usephiCut) { float phi = track.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < trackCuts.minPhi || trackCuts.maxPhi < phi) { - return false; - } if ((phi < trackCuts.phiCut) || ((phi > PI - trackCuts.phiCut) && (phi < PI + trackCuts.phiCut)) || (phi > TwoPI - trackCuts.phiCut) || @@ -1541,19 +791,19 @@ struct DndetaMFTPbPb { } } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelPhiCut)); + registryQC.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelPhiCut)); } if (trackCuts.usePtCut && track.pt() < trackCuts.minPt) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelPt)); + registryQC.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelPt)); } if (trackCuts.requireCA && !track.isCA()) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelCA)); + registryQC.fill(HIST("Tracks/hTrkSel"), static_cast(TrkSel::trkSelCA)); } return true; } @@ -1565,49 +815,31 @@ struct DndetaMFTPbPb { for (auto const& track : tracks) { if (fillHis) { if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/Chi2Eta"), track.chi2(), track.eta(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/Chi2"), track.chi2(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/NclustersEta"), track.nClusters(), track.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/Chi2Eta"), track.chi2(), track.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/NclustersEta"), track.nClusters(), track.eta(), c, occ); } else { - qaregistry.fill(HIST("Tracks/Chi2Eta"), track.chi2(), track.eta(), occ); - qaregistry.fill(HIST("Tracks/Chi2"), track.chi2(), occ); - qaregistry.fill(HIST("Tracks/NclustersEta"), track.nClusters(), track.eta(), occ); + registryData.fill(HIST("Tracks/Chi2Eta"), track.chi2(), track.eta(), occ); + registryData.fill(HIST("Tracks/NclustersEta"), track.nClusters(), track.eta(), occ); } } if (!isTrackSelected(track)) { continue; } if (fillHis) { - float phi = track.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } if constexpr (has_reco_cent) { - registry.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c, occ); - registry.fill(HIST("Tracks/Centrality/PhiEta"), phi, track.eta(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/TanLambda"), track.tgl(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/InvQPt"), track.signed1Pt(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/Eta"), track.eta(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/Phi"), phi, c, occ); + registryData.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c, occ); + registryData.fill(HIST("Tracks/Centrality/PhiEta"), track.phi(), track.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/TanLambda"), track.tgl(), c, occ); + registryData.fill(HIST("Tracks/Centrality/InvQPt"), track.signed1Pt(), c, occ); } else { - registry.fill(HIST("Tracks/EtaZvtx"), track.eta(), z, occ); - registry.fill(HIST("Tracks/PhiEta"), phi, track.eta(), occ); - qaregistry.fill(HIST("Tracks/TanLambda"), track.tgl(), c, occ); - qaregistry.fill(HIST("Tracks/InvQPt"), track.signed1Pt(), c, occ); - qaregistry.fill(HIST("Tracks/Eta"), track.eta(), c, occ); - qaregistry.fill(HIST("Tracks/Phi"), phi, c, occ); + registryData.fill(HIST("Tracks/EtaZvtx"), track.eta(), z, occ); + registryData.fill(HIST("Tracks/PhiEta"), track.phi(), track.eta(), occ); + registryData.fill(HIST("Tracks/TanLambda"), track.tgl(), occ); + registryData.fill(HIST("Tracks/InvQPt"), track.signed1Pt(), occ); } } ++nTrk; } - if (fillHis) { - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/NchSel"), nTrk, c, occ); - } else { - qaregistry.fill(HIST("Tracks/NchSel"), nTrk, occ); - } - } return nTrk; } @@ -1616,24 +848,19 @@ struct DndetaMFTPbPb { { for (auto const& etrack : besttracksExtra) { if (fillHis) { - float phi = etrack.phis(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } if constexpr (has_reco_cent) { if (gConf.cfgUseTrackParExtra) { - qaregistry.fill(HIST("Tracks/Centrality/TanLambdaExtra"), etrack.tgl(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/InvQPtExtra"), etrack.signed1Pt(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/EtaExtra"), etrack.etas(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/PhiExtra"), phi, c, occ); + registryData.fill(HIST("Tracks/Centrality/TanLambdaExtra"), etrack.tgl(), c, occ); + registryData.fill(HIST("Tracks/Centrality/InvQPtExtra"), etrack.signed1Pt(), c, occ); + registryData.fill(HIST("Tracks/Centrality/EtaExtra"), etrack.etas(), c, occ); + registryData.fill(HIST("Tracks/Centrality/PhiExtra"), etrack.phis(), c, occ); } } else { if (gConf.cfgUseTrackParExtra) { - qaregistry.fill(HIST("Tracks/TanLambdaExtra"), etrack.tgl(), occ); - qaregistry.fill(HIST("Tracks/InvQPtExtra"), etrack.signed1Pt(), occ); - qaregistry.fill(HIST("Tracks/EtaExtra"), etrack.etas(), occ); - qaregistry.fill(HIST("Tracks/PhiExtra"), phi, occ); + registryData.fill(HIST("Tracks/TanLambdaExtra"), etrack.tgl(), occ); + registryData.fill(HIST("Tracks/InvQPtExtra"), etrack.signed1Pt(), occ); + registryData.fill(HIST("Tracks/EtaExtra"), etrack.etas(), occ); + registryData.fill(HIST("Tracks/PhiExtra"), etrack.phis(), occ); } } } @@ -1641,8 +868,7 @@ struct DndetaMFTPbPb { } template - int countBestTracks(T const& tracks, B const& besttracks, float z, - float c, float occ) + int countBestTracks(T const& tracks, B const& besttracks, float z, float c, float occ) { auto nATrk = 0; ambiguousTrkIds.reserve(besttracks.size()); @@ -1653,47 +879,45 @@ struct DndetaMFTPbPb { } const float bestDcaZ = getDCAz(atrack); auto itrack = atrack.template mfttrack_as(); + if constexpr (has_reco_cent) { + registryData.fill(HIST("Tracks/Centrality/Chi2Eta"), itrack.chi2(), itrack.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/NclustersEta"), itrack.nClusters(), itrack.eta(), c, occ); + } else { + registryData.fill(HIST("Tracks/Chi2Eta"), itrack.chi2(), itrack.eta(), occ); + registryData.fill(HIST("Tracks/NclustersEta"), itrack.nClusters(), itrack.eta(), occ); + } if (!isTrackSelected(itrack)) { continue; } ambiguousTrkIds.emplace_back(atrack.mfttrackId()); ++nATrk; if (fillHis) { - float phi = itrack.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } if constexpr (has_reco_cent) { - registry.fill(HIST("Tracks/Centrality/EtaZvtxBest"), itrack.eta(), z, c, occ); - registry.fill(HIST("Tracks/Centrality/PhiEtaBest"), phi, itrack.eta(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/DCA3d"), itrack.pt(), itrack.eta(), atrack.bestDCAXY(), bestDcaZ, c, occ); - qaregistry.fill(HIST("Tracks/Centrality/NclustersEtaBest"), itrack.nClusters(), itrack.eta(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/TrackAmbDegree"), atrack.ambDegree(), c, occ); + registryData.fill(HIST("Tracks/Centrality/EtaZvtx"), itrack.eta(), z, c, occ); + registryData.fill(HIST("Tracks/Centrality/PhiEta"), itrack.phi(), itrack.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/TanLambda"), itrack.tgl(), c, occ); + registryData.fill(HIST("Tracks/Centrality/InvQPt"), itrack.signed1Pt(), c, occ); + registryData.fill(HIST("Tracks/Centrality/DCA3d"), itrack.pt(), itrack.eta(), atrack.bestDCAXY(), bestDcaZ, c, occ); + registryData.fill(HIST("Tracks/Centrality/TrackAmbDegree"), atrack.ambDegree(), c, occ); } else { - registry.fill(HIST("Tracks/EtaZvtxBest"), itrack.eta(), z, occ); - registry.fill(HIST("Tracks/PhiEtaBest"), phi, itrack.eta(), occ); - qaregistry.fill(HIST("Tracks/DCA3d"), itrack.pt(), itrack.eta(), atrack.bestDCAXY(), bestDcaZ, occ); - qaregistry.fill(HIST("Tracks/NclustersEtaBest"), itrack.nClusters(), itrack.eta(), occ); - qaregistry.fill(HIST("Tracks/TrackAmbDegree"), atrack.ambDegree(), occ); + registryData.fill(HIST("Tracks/EtaZvtx"), itrack.eta(), z, occ); + registryData.fill(HIST("Tracks/PhiEta"), itrack.phi(), itrack.eta(), occ); + registryData.fill(HIST("Tracks/TanLambda"), itrack.tgl(), occ); + registryData.fill(HIST("Tracks/InvQPt"), itrack.signed1Pt(), occ); + registryData.fill(HIST("Tracks/DCA3d"), itrack.pt(), itrack.eta(), atrack.bestDCAXY(), bestDcaZ, occ); + registryData.fill(HIST("Tracks/TrackAmbDegree"), atrack.ambDegree(), occ); } } - if (itrack.has_collision() && itrack.collisionId() != atrack.bestCollisionId()) { reassignedTrkIds.emplace_back(atrack.mfttrackId()); if (fillHis) { - registry.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkTrkBestSel::trkTrkBestSelNumReassoc)); - float phi = itrack.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } + registryQC.fill(HIST("Tracks/hBestTrkSel"), static_cast(TrkBestSel::trkBestSelNumReassoc)); if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/ReTracksEtaZvtx"), itrack.eta(), itrack.template collision_as().posZ(), c, occ); - qaregistry.fill(HIST("Tracks/Centrality/ReTracksPhiEta"), phi, itrack.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/ReTracksEtaZvtx"), itrack.eta(), itrack.template collision_as().posZ(), c, occ); + registryData.fill(HIST("Tracks/Centrality/ReTracksPhiEta"), itrack.phi(), itrack.eta(), c, occ); } else { - qaregistry.fill(HIST("Tracks/ReTracksEtaZvtx"), itrack.eta(), itrack.template collision_as().posZ(), occ); - qaregistry.fill(HIST("Tracks/ReTracksPhiEta"), phi, itrack.eta(), occ); + registryData.fill(HIST("Tracks/ReTracksEtaZvtx"), itrack.eta(), itrack.template collision_as().posZ(), occ); + registryData.fill(HIST("Tracks/ReTracksPhiEta"), itrack.phi(), itrack.eta(), occ); } } } @@ -1703,18 +927,13 @@ struct DndetaMFTPbPb { if (!isTrackSelected(track)) { continue; } - float phi = track.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } if (fillHis) { if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/OrigTracksEtaZvtx"), track.eta(), z, c, occ); - qaregistry.fill(HIST("Tracks/Centrality/OrigTracksPhiEta"), phi, track.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/OrigTracksEtaZvtx"), track.eta(), z, c, occ); + registryData.fill(HIST("Tracks/Centrality/OrigTracksPhiEta"), track.phi(), track.eta(), c, occ); } else { - qaregistry.fill(HIST("Tracks/OrigTracksEtaZvtx"), track.eta(), z, occ); - qaregistry.fill(HIST("Tracks/OrigTracksPhiEta"), phi, track.eta(), occ); + registryData.fill(HIST("Tracks/OrigTracksEtaZvtx"), track.eta(), z, occ); + registryData.fill(HIST("Tracks/OrigTracksPhiEta"), track.phi(), track.eta(), occ); } } if (std::find(ambiguousTrkIds.begin(), ambiguousTrkIds.end(), track.globalIndex()) != ambiguousTrkIds.end()) { @@ -1726,27 +945,20 @@ struct DndetaMFTPbPb { // ++nATrk; // use for testing purposes only! if (fillHis) { if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/RestTracksEtaZvtx"), track.eta(), z, c, occ); - qaregistry.fill(HIST("Tracks/Centrality/RestTracksPhiEta"), phi, track.eta(), c, occ); - // registry.fill(HIST("Tracks/Centrality/EtaZvtxBest"), track.eta(), z, c, occ); - // registry.fill(HIST("Tracks/Centrality/PhiEtaBest"), phi, track.eta(), c, occ); - // qaregistry.fill(HIST("Tracks/Centrality/NclustersEtaBest"), track.nClusters(), track.eta(), c, occ); + registryData.fill(HIST("Tracks/Centrality/RestTracksEtaZvtx"), track.eta(), z, c, occ); + registryData.fill(HIST("Tracks/Centrality/RestTracksPhiEta"), track.phi(), track.eta(), c, occ); + // registryData.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c, occ); + // registryData.fill(HIST("Tracks/Centrality/PhiEta"), phi, track.eta(), c, occ); + // registryData.fill(HIST("Tracks/Centrality/NclustersEta"), track.nClusters(), track.eta(), c, occ); } else { - qaregistry.fill(HIST("Tracks/RestTracksEtaZvtx"), track.eta(), z, occ); - qaregistry.fill(HIST("Tracks/RestTracksPhiEta"), phi, track.eta(), occ); - // registry.fill(HIST("Tracks/EtaZvtxBest"), track.eta(), z, occ); - // registry.fill(HIST("Tracks/PhiEtaBest"), phi, track.eta(), occ); - // qaregistry.fill(HIST("Tracks/NclustersEtaBest"), track.nClusters(), track.eta(), occ); + registryData.fill(HIST("Tracks/RestTracksEtaZvtx"), track.eta(), z, occ); + registryData.fill(HIST("Tracks/RestTracksPhiEta"), track.phi(), track.eta(), occ); + // registryData.fill(HIST("Tracks/EtaZvtx"), track.eta(), z, occ); + // registryData.fill(HIST("Tracks/PhiEta"), phi, track.eta(), occ); + // registryData.fill(HIST("Tracks/NclustersEta"), track.nClusters(), track.eta(), occ); } } } - if (fillHis) { - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/NchBestSel"), nATrk, c, occ); - } else { - qaregistry.fill(HIST("Tracks/NchBestSel"), nATrk, occ); - } - } ambiguousTrkIds.clear(); ambiguousTrkIds.shrink_to_fit(); reassignedTrkIds.clear(); @@ -1754,59 +966,6 @@ struct DndetaMFTPbPb { return nATrk; } - template - int countPartMidRap(P const& particles) - { - int nCh = 0; - for (auto const& part : particles) { - if (!isChrgParticle(part.pdgCode())) { - continue; - } - if (!part.isPhysicalPrimary()) { - continue; - } - if (part.eta() < trackCuts.minEtaGenMult || part.eta() > trackCuts.maxEtaGenMult) { - continue; - } - nCh++; - } - return nCh; - } - - float getCentGenMult(int nCharged) - { - const auto& genMultBinLimits = binOpt.genMultBins.value; - const auto& recCentBinVal = binOpt.recCentBinCenters.value; - if (genMultBinLimits.size() != recCentBinVal.size()) { - LOGF(fatal, "genMultBinLimits size (%zu) is different from recCentBinVal size (%zu)", genMultBinLimits.size(), recCentBinVal.size()); - } - for (size_t i = 0; i < genMultBinLimits.size(); ++i) { - if (nCharged >= genMultBinLimits[i]) { - return recCentBinVal[i]; - } - } - return CInvalid; - } - - template - int countPart(P const& particles) - { - auto nCharged = 0; - for (auto const& particle : particles) { - if (!isChrgParticle(particle.pdgCode())) { - continue; - } - if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { - continue; - } - if (particle.eta() < trackCuts.minEta || particle.eta() > trackCuts.maxEta) { - continue; - } - nCharged++; - } - return nCharged; - } - template bool isInelGt0wMft(P const& particles) { @@ -1833,16 +992,34 @@ struct DndetaMFTPbPb { } nChrgMc++; } - if (nChrgFT0A == CintZero || nChrgFT0C == CintZero) { - registry.fill(HIST("Events/hNchTVX"), nChrgMc, 0.5); + registryMC.fill(HIST("Events/hNchTVX"), nChrgMc, 0.5); return false; } - registry.fill(HIST("Events/hNchTVX"), nChrgMc, 1.5); + registryMC.fill(HIST("Events/hNchTVX"), nChrgMc, 1.5); return nChrgMc != CintZero; } + template + int countPart(P const& particles) + { + auto nCharged = 0; + for (auto const& particle : particles) { + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + continue; + } + if (particle.eta() < trackCuts.minEta || particle.eta() > trackCuts.maxEta) { + continue; + } + nCharged++; + } + return nCharged; + } + template bool isParticleSelected(P const& particle) { @@ -1857,10 +1034,6 @@ struct DndetaMFTPbPb { } if (trackCuts.usephiCut) { float phi = particle.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < trackCuts.minPhi || trackCuts.maxPhi < phi) { - return false; - } if ((phi < trackCuts.phiCut) || ((phi > PI - trackCuts.phiCut) && (phi < PI + trackCuts.phiCut)) || (phi > TwoPI - trackCuts.phiCut) || @@ -1872,6 +1045,16 @@ struct DndetaMFTPbPb { return true; } + template + bool cutInPhi(P const& particle) + { + if (!trackCuts.usephiCut) { + return true; + } + auto phi = particle.phi(); + return (phi < trackCuts.phiCut) || ((phi > PI - trackCuts.phiCut) && (phi < PI + trackCuts.phiCut)) || (phi > TwoPI - trackCuts.phiCut) || ((phi > ((PIHalf - 0.1) * PI) - trackCuts.phiCut) && (phi < ((PIHalf - 0.1) * PI) + trackCuts.phiCut)); + } + template float getOccupancy(C const& collision, uint occEstimator) { @@ -1900,7 +1083,7 @@ struct DndetaMFTPbPb { float maxSec = std::ceil(runDuration.second * 1.e-3); /// round tsEOR to the lowest integer higher than tsEOR const AxisSpec axisSeconds{static_cast((maxSec - mMinSeconds) / 20.f), 0, maxSec - mMinSeconds, "Seconds since SOR"}; int hadronicRateBins = static_cast(eventCuts.maxIR - eventCuts.minIR); - gHadronicRate[mRunNumber] = registry.add(Form("HadronicRate/%i", mRunNumber), ";Time since SOR (s);Hadronic rate (kHz)", kTH2D, {axisSeconds, {hadronicRateBins, eventCuts.minIR, eventCuts.maxIR}}).get(); + gHadronicRate[mRunNumber] = registryMC.add(Form("HadronicRate/%i", mRunNumber), ";Time since SOR (s);Hadronic rate (kHz)", kTH2D, {axisSeconds, {hadronicRateBins, eventCuts.minIR, eventCuts.maxIR}}).get(); } gCurrentHadronicRate = gHadronicRate[mRunNumber]; } @@ -1909,75 +1092,75 @@ struct DndetaMFTPbPb { bool isGoodEvent(C const& collision) { if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtAll)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtAll)); } if (!collision.sel8()) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtSel)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtSel)); } if (eventCuts.requireIsGoodZvtxFT0VsPV && !collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtIsGoodZvtx)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtIsGoodZvtx)); } if (eventCuts.requireRejectSameBunchPileup && !collision.selection_bit(aod::evsel::kNoSameBunchPileup)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoSameBunchPileup)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoSameBunchPileup)); } if (collision.posZ() <= eventCuts.minZvtx || collision.posZ() >= eventCuts.maxZvtx) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtZvtxCut)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtZvtxCut)); } if (eventCuts.requireNoCollInTimeRangeStd && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInTimeRangeStd)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInTimeRangeStd)); } if (eventCuts.requireNoCollInTimeRangeNarrow && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeNarrow)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInTimeRangeNarrow)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInTimeRangeNarrow)); } if (eventCuts.requireNoCollInTimeRangeStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStrict)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInTimeRangeStrict)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInTimeRangeStrict)); } if (eventCuts.requireNoCollInRofStrict && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStrict)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInRofStrict)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInRofStrict)); } if (eventCuts.requireNoCollInRofStandard && !collision.selection_bit(o2::aod::evsel::kNoCollInRofStandard)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInRofStandard)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoCollInRofStandard)); } if (eventCuts.requireNoHighMultCollInPrevRof && !collision.selection_bit(o2::aod::evsel::kNoHighMultCollInPrevRof)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoHighMultCollInPrevRof)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtNoHighMultCollInPrevRof)); } if (eventCuts.requireGoodITSLayersAll && !collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtGoodITSLayersAll)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtGoodITSLayersAll)); } if (eventCuts.minOccupancy >= 0 && getOccupancy(collision, eventCuts.occupancyEstimator) < @@ -1985,7 +1168,7 @@ struct DndetaMFTPbPb { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtBelowMinOccup)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtBelowMinOccup)); } if (eventCuts.maxOccupancy >= 0 && getOccupancy(collision, eventCuts.occupancyEstimator) > @@ -1993,19 +1176,19 @@ struct DndetaMFTPbPb { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtAboveMaxOccup)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtAboveMaxOccup)); } if (rctCuts.requireRCTFlagChecker && !rctChecker(collision)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtRCTFlagChecker)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtRCTFlagChecker)); } if (rctCuts.requireRCTFlagCheckerExtra && !rctCheckerExtra(collision)) { return false; } if constexpr (fillHis) { - registry.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtRCTFlagCheckerExtra)); + registryQC.fill(HIST("Events/hEvtSel"), static_cast(EvtSel::evtRCTFlagCheckerExtra)); } return true; } @@ -2023,8 +1206,7 @@ struct DndetaMFTPbPb { } template - void fillHistMC(P const& particles, float c, float occ, float zvtx, - bool const gtZeroColl) + void fillHistMC(P const& particles, float zvtx, float c, float occ) { for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { @@ -2033,37 +1215,12 @@ struct DndetaMFTPbPb { if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { continue; } - - float phi = particle.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } if constexpr (isCent) { - registry.fill(HIST("Tracks/Centrality/EtaZvtxGen_t"), particle.eta(), - zvtx, c); - registry.fill(HIST("Tracks/Centrality/PhiEtaGen_t"), phi, - particle.eta(), c); + registryMC.fill(HIST("Tracks/Centrality/EtaZvtxGen"), particle.eta(), zvtx, c, occ); + registryMC.fill(HIST("Tracks/Centrality/PhiEtaGen"), particle.phi(), particle.eta(), c, occ); } else { - registry.fill(HIST("Tracks/EtaZvtxGen_t"), particle.eta(), zvtx); - registry.fill(HIST("Tracks/PhiEtaGen_t"), phi, particle.eta()); - } - - if (gtZeroColl) { - float phi = particle.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } - if constexpr (isCent) { - registry.fill(HIST("Tracks/Centrality/EtaZvtxGen"), particle.eta(), - zvtx, c, occ); - registry.fill(HIST("Tracks/Centrality/PhiEtaGen"), phi, - particle.eta(), c, occ); - } else { - registry.fill(HIST("Tracks/EtaZvtxGen"), particle.eta(), zvtx, occ); - registry.fill(HIST("Tracks/PhiEtaGen"), phi, particle.eta(), occ); - } + registryMC.fill(HIST("Tracks/EtaZvtxGen"), particle.eta(), zvtx, occ); + registryMC.fill(HIST("Tracks/PhiEtaGen"), particle.phi(), particle.eta(), occ); } } } @@ -2075,7 +1232,7 @@ struct DndetaMFTPbPb { for (auto const& bc : bcs) { if (static_cast(bc.selection_bit(aod::evsel::kIsBBT0A) && bc.selection_bit(aod::evsel::kIsBBT0C)) != 0) { - registry.fill(HIST("hBcSel"), 0); + registryQC.fill(HIST("hBcSel"), 0); cols.clear(); for (auto const& collision : collisions) { if (collision.has_foundBC()) { @@ -2088,49 +1245,38 @@ struct DndetaMFTPbPb { } LOGP(debug, "BC {} has {} collisions", bc.globalBC(), cols.size()); if (!cols.empty()) { - registry.fill(HIST("hBcSel"), 1); + registryQC.fill(HIST("hBcSel"), 1); if (cols.size() > 1) { - registry.fill(HIST("hBcSel"), 2); + registryQC.fill(HIST("hBcSel"), 2); } } } } } - PROCESS_SWITCH(DndetaMFTPbPb, processTagging, "Collect event sample stats", - true); + PROCESS_SWITCH(DndetaMFTPbPb, processTagging, "Collect event sample stats", true); /// @brief process function for counting tracks template void processData(typename C::iterator const& collision, - FiltMftTracks const& tracks, CollBCs const& /*bcs*/) + aod::MFTTracks const& tracks, + CollBCs const& /*bcs*/) { - auto occ = getOccupancy(collision, eventCuts.occupancyEstimator); float c = getRecoCent(collision); + float occ = getOccupancy(collision, eventCuts.occupancyEstimator); auto bc = collision.template foundBC_as(); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/Selection"), 1., c, occ); + registryData.fill(HIST("Events/Centrality/Selection"), 1., c, occ); } else { - registry.fill(HIST("Events/Selection"), 1., occ); + registryData.fill(HIST("Events/Selection"), 1., occ); } - - // const bool isFT0Bad = bc.rct_bit(kFT0Bad); - // registry.fill(HIST("Events/hRCTSel"), 1.0); - // if (!isFT0Bad) { - // registry.fill(HIST("Events/hRCTSel"), 2.0); - // } - - if (!isGoodEvent(collision)) { - return; - } - if (gConf.cfgDoIR) { initHadronicRate(bc); float ir = !gConf.cfgIRSource.value.empty() ? rateFetcher.fetch(ccdb.service, bc.timestamp(), bc.runNumber(), gConf.cfgIRSource, gConf.cfgIRCrashOnNull) * 1.e-3 : -1; if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/hInteractionRate"), c, occ, ir); + registryData.fill(HIST("Events/Centrality/hInteractionRate"), ir, c, occ); } else { - registry.fill(HIST("Events/hInteractionRate"), occ, ir); + registryData.fill(HIST("Events/hInteractionRate"), ir, occ); } float seconds = bc.timestamp() * 1.e-3 - mMinSeconds; if (gConf.cfgUseIRCut && (ir < eventCuts.minIR || ir > eventCuts.maxIR)) { // cut on hadronic rate @@ -2138,50 +1284,49 @@ struct DndetaMFTPbPb { } gCurrentHadronicRate->Fill(seconds, ir); } - + if (!isGoodEvent(collision)) { + return; + } auto z = collision.posZ(); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/Selection"), 2., c, occ); + registryData.fill(HIST("Events/Centrality/Selection"), 2., c, occ); + registryData.fill(HIST("Events/Centrality/hZvtxCent"), z, c, occ); } else { - registry.fill(HIST("Events/Selection"), 2., occ); + registryData.fill(HIST("Events/Selection"), 2., occ); } auto nTrk = countTracks(tracks, z, c, occ); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/NtrkZvtx"), nTrk, z, c, occ); + registryData.fill(HIST("Events/Centrality/NtrkZvtx"), nTrk, z, c, occ); } else { - registry.fill(HIST("Events/NtrkZvtx"), nTrk, z, occ); + registryData.fill(HIST("Events/NtrkZvtx"), nTrk, z, occ); } } - /// @brief process function for counting tracks (based on BestCollisionsFwd3d - /// table) + /// @brief process function for counting tracks (based on BestCollisionsFwd3d table) template - void processDatawBestTracks( - typename C::iterator const& collision, FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& /*bcs*/) + void processDatawBestTracks(typename C::iterator const& collision, + aod::MFTTracks const& tracks, + soa::SmallGroups const& besttracks, + aod::BestCollisionsFwd3dExtra const& besttracksExtra, + CollBCs const& /*bcs*/) { - auto occ = getOccupancy(collision, eventCuts.occupancyEstimator); float c = getRecoCent(collision); + float occ = getOccupancy(collision, eventCuts.occupancyEstimator); auto bc = collision.template foundBC_as(); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/Selection"), 1., c, occ); + registryData.fill(HIST("Events/Centrality/Selection"), 1., c, occ); } else { - registry.fill(HIST("Events/Selection"), 1., occ); - } - - if (!isGoodEvent(collision)) { - return; + registryData.fill(HIST("Events/Selection"), 1., occ); } - if (gConf.cfgDoIR) { initHadronicRate(bc); float ir = !gConf.cfgIRSource.value.empty() ? rateFetcher.fetch(ccdb.service, bc.timestamp(), bc.runNumber(), gConf.cfgIRSource, gConf.cfgIRCrashOnNull) * 1.e-3 : -1; if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/hInteractionRate"), c, occ, ir); + registryData.fill(HIST("Events/Centrality/hInteractionRate"), ir, c, occ); } else { - registry.fill(HIST("Events/hInteractionRate"), occ, ir); + registryData.fill(HIST("Events/hInteractionRate"), ir, occ); } float seconds = bc.timestamp() * 1.e-3 - mMinSeconds; if (gConf.cfgUseIRCut && (ir < eventCuts.minIR || ir > eventCuts.maxIR)) { // cut on hadronic rate @@ -2189,169 +1334,81 @@ struct DndetaMFTPbPb { } gCurrentHadronicRate->Fill(seconds, ir); } - + if (!isGoodEvent(collision)) { + return; + } auto z = collision.posZ(); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/Selection"), 2., c, occ); - qaregistry.fill(HIST("Events/Centrality/hZvtxCent"), z, c, occ); - qaregistry.fill(HIST("Events/Centrality/hCent"), c, occ); + registryData.fill(HIST("Events/Centrality/Selection"), 2., c, occ); + registryData.fill(HIST("Events/Centrality/hZvtxCent"), z, c, occ); } else { - registry.fill(HIST("Events/Selection"), 2., occ); + registryData.fill(HIST("Events/Selection"), 2., occ); + registryData.fill(HIST("Events/hZvtxCent"), z, c, occ); } auto nBestTrks = countBestTracks(tracks, besttracks, z, c, occ); countBestTracksExtra(besttracksExtra, c, occ); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/NtrkZvtxBest"), nBestTrks, z, c, - occ); + registryData.fill(HIST("Events/Centrality/NtrkZvtx"), nBestTrks, z, c, occ); } else { - registry.fill(HIST("Events/NtrkZvtxBest"), nBestTrks, z, occ); + registryData.fill(HIST("Events/NtrkZvtx"), nBestTrks, z, occ); } } - void processDataInclusive(Colls::iterator const& collision, - FiltMftTracks const& tracks, CollBCs const& bcs) + void processDataInclusive(Colls::iterator const& collision, aod::MFTTracks const& tracks, CollBCs const& bcs) { processData(collision, tracks, bcs); } - PROCESS_SWITCH(DndetaMFTPbPb, processDataInclusive, - "Count tracks (inclusive)", false); + PROCESS_SWITCH(DndetaMFTPbPb, processDataInclusive, "Count tracks (inclusive)", false); - void processDataCentFT0C(CollsCentFT0C::iterator const& collision, - FiltMftTracks const& tracks, CollBCs const& bcs) + void processDataCentFT0C(CollsCentFT0C::iterator const& collision, aod::MFTTracks const& tracks, CollBCs const& bcs) { processData(collision, tracks, bcs); } - PROCESS_SWITCH(DndetaMFTPbPb, processDataCentFT0C, - "Count tracks in FT0C centrality bins", false); - - void - processDataCentFT0CVariant1(CollsCentFT0CVariant1::iterator const& collision, - FiltMftTracks const& tracks, CollBCs const& bcs) - { - processData(collision, tracks, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDataCentFT0CVariant1, - "Count tracks in FT0CVariant1 centrality bins", false); - - void processDataCentFT0M(CollsCentFT0M::iterator const& collision, - FiltMftTracks const& tracks, CollBCs const& bcs) - { - processData(collision, tracks, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDataCentFT0M, - "Count tracks in FT0M centrality bins", false); - - void processDataCentNGlobal(CollsCentNGlobal::iterator const& collision, - FiltMftTracks const& tracks, CollBCs const& bcs) - { - processData(collision, tracks, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDataCentNGlobal, - "Count tracks in NGlobal centrality bins", false); - - void processDataCentMFT(CollsCentMFT::iterator const& collision, - FiltMftTracks const& tracks, CollBCs const& bcs) - { - processData(collision, tracks, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDataCentMFT, - "Count tracks in MFT centrality bins", false); + PROCESS_SWITCH(DndetaMFTPbPb, processDataCentFT0C, "Count tracks in FT0C centrality bins", false); - void processDatawBestTracksInclusive( - Colls::iterator const& collision, FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) + void processDatawBestTracksInclusive(Colls::iterator const& collision, aod::MFTTracks const& tracks, soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) { processDatawBestTracks(collision, tracks, besttracks, besttracksExtra, bcs); } - PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksInclusive, - "Count tracks based on BestCollisionsFwd3d table (inclusive)", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksInclusive, "Count tracks based on BestCollisionsFwd3d table (inclusive)", false); - void processDatawBestTracksCentFT0C( - CollsCentFT0C::iterator const& collision, FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) + void processDatawBestTracksCentFT0C(CollsCentFT0C::iterator const& collision, aod::MFTTracks const& tracks, soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) { processDatawBestTracks(collision, tracks, besttracks, besttracksExtra, bcs); } - PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentFT0C, - "Count tracks in FT0C centrality bins based on BestCollisionsFwd3d table", - false); - - void processDatawBestTracksCentFT0CVariant1( - CollsCentFT0CVariant1::iterator const& collision, - FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) - { - processDatawBestTracks(collision, tracks, besttracks, besttracksExtra, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentFT0CVariant1, - "Count tracks in FT0CVariant1 centrality bins based on " - "BestCollisionsFwd3d table", - false); - - void processDatawBestTracksCentFT0M( - CollsCentFT0M::iterator const& collision, FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) - { - processDatawBestTracks(collision, tracks, besttracks, besttracksExtra, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentFT0M, - "Count tracks in FT0M centrality bins based on BestCollisionsFwd3d table", - false); - - void processDatawBestTracksCentNGlobal( - CollsCentNGlobal::iterator const& collision, FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) - { - processDatawBestTracks(collision, tracks, besttracks, besttracksExtra, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentNGlobal, - "Count tracks in NGlobal centrality bins based on " - "BestCollisionsFwd3d table", - false); - - void processDatawBestTracksCentMFT( - CollsCentMFT::iterator const& collision, FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, aod::BestCollisionsFwd3dExtra const& besttracksExtra, CollBCs const& bcs) - { - processDatawBestTracks(collision, tracks, besttracks, besttracksExtra, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentMFT, - "Count tracks in MFT centrality bins based on BestCollisionsFwd3d table", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processDatawBestTracksCentFT0C, "Count tracks in FT0C centrality bins based on BestCollisionsFwd3d table", false); - Preslice perCol = o2::aod::fwdtrack::collisionId; - PresliceUnsorted recColPerMcCol = - aod::mccollisionlabel::mcCollisionId; + Preslice perCol = o2::aod::fwdtrack::collisionId; Partition mcSample = (aod::mcparticle::eta < trackCuts.maxEta) && (aod::mcparticle::eta > trackCuts.minEta); - /// @brief process template function to run on MC gen template - void processMC( - typename MC::iterator const& mcCollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks) + void processMC(typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) { - bool gtZeroColl = false; - int gtOneColl = 0; - + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + float occGen = -1.; + for (const auto& collision : collisions) { + if (isGoodEvent(collision)) { + float o = getOccupancy(collision, eventCuts.occupancyEstimator); + if (o > occGen) { + occGen = o; + } + } + } float cGen = -1; + if (eventCuts.useGenMult) { + cGen = mcCollision.multMCFT0C(); + } if constexpr (has_reco_cent) { - float crecMin = 105.f; + float crecMin = 999.; for (const auto& collision : collisions) { if (isGoodEvent(collision)) { float c = getRecoCent(collision); @@ -2365,197 +1422,150 @@ struct DndetaMFTPbPb { } } - float occGen = -1.; - for (const auto& collision : collisions) { - if (isGoodEvent(collision)) { - float o = getOccupancy(collision, eventCuts.occupancyEstimator); - if (o > occGen) { - occGen = o; - } - } - } - for (auto const& collision : collisions) { - float occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - float crec = getRecoCent(collision); - + float occRec = getOccupancy(collision, eventCuts.occupancyEstimator); + float cRec = getRecoCent(collision); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., crec, occrec); + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecAll), cRec, occRec); } else { - registry.fill(HIST("Events/EvtEffGen"), 1., occrec); + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecAll), occRec); + } + if (!isGoodEvent(collision)) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecSel), cRec, occRec); + } else { + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecSel), occRec); + } + if (!collision.has_mcCollision()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecHasMcColl), cRec, occRec); + } else { + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecHasMcColl), occRec); + } + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecNoSplitVtx), cRec, occRec); + registryMC.fill(HIST("Events/Centrality/hRecZvtxCent"), collision.posZ(), cRec, occRec); + } else { + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecNoSplitVtx), occRec); } - if (isGoodEvent(collision)) { - gtZeroColl = true; - ++gtOneColl; - auto z = collision.posZ(); - - if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., crec, occrec); - registry.fill(HIST("Events/Centrality/hRecCent"), crec, occrec); - registry.fill(HIST("Events/Centrality/hRecZvtxCent"), z, crec, - occrec); - } else { - registry.fill(HIST("Events/EvtEffGen"), 2., occrec); - } - - auto perColSample = tracks.sliceBy(perCol, collision.globalIndex()); - auto nTrkRec = countTracks(perColSample, z, crec, occrec); - - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Events/Centrality/ZvtxDiff"), - collision.posZ() - mcCollision.posZ(), crec); - } else { - qaregistry.fill(HIST("Events/ZvtxDiff"), - collision.posZ() - mcCollision.posZ()); + auto nTrkRec = 0; + auto perColSample = tracks.sliceBy(perCol, collision.globalIndex()); + for (auto const& track : perColSample) { + if (!isTrackSelected(track)) { + continue; } - - if (eventCuts.useZDiffCut) { - if (std::abs(collision.posZ() - mcCollision.posZ()) > - eventCuts.maxZvtxDiff) { + if (track.has_mcParticle() && track.mcMask() == trackCuts.selMcMask) { + const auto& particle = track.template mcParticle_as(); + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + continue; + } + if (collision.mcCollisionId() != particle.mcCollisionId()) { continue; } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), collision.posZ(), cRec, occRec); + registryMC.fill(HIST("Tracks/Centrality/PhiEta"), track.phi(), track.eta(), cRec, occRec); + registryMC.fill(HIST("Tracks/Centrality/NclustersEta"), track.nClusters(), track.eta(), cRec, occRec); + } else { + registryMC.fill(HIST("Tracks/EtaZvtx"), track.eta(), collision.posZ(), occRec); + registryMC.fill(HIST("Tracks/PhiEta"), track.phi(), track.eta(), occRec); + registryMC.fill(HIST("Tracks/NclustersEta"), track.nClusters(), track.eta(), occRec); + } + ++nTrkRec; } - - if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, - collision.posZ(), crec, occrec); - } else { - registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, collision.posZ(), - occrec); + } + if (eventCuts.useZDiffCut) { + if (std::abs(collision.posZ() - mcCollision.posZ()) > eventCuts.maxZvtxDiff) { + continue; } } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, collision.posZ(), cRec, occRec); + registryMC.fill(HIST("Events/Centrality/ZvtxDiff"), collision.posZ() - mcCollision.posZ(), cRec, occRec); + } else { + registryMC.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, collision.posZ(), occRec); + registryMC.fill(HIST("Events/ZvtxDiff"), collision.posZ() - mcCollision.posZ(), occRec); + } } if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., cGen, occGen); + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcGenAll), cGen, occGen); } else { - registry.fill(HIST("Events/EvtEffGen"), 3., occGen); - } - - auto perCollMCsample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); - auto nchrg = countPart(perCollMCsample); - auto zvtxMC = mcCollision.posZ(); - - if (gtOneColl > 1) { - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Events/Centrality/SplitMult"), nchrg, zvtxMC, cGen); - } else { - qaregistry.fill(HIST("Events/SplitMult"), nchrg, zvtxMC); - } + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcGenAll), occGen); } auto nCharged = countPart(particles); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, zvtxMC, - cGen); + registryMC.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, mcCollision.posZ(), cGen, occGen); } else { - registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); + registryMC.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, mcCollision.posZ(), occGen); } - - fillHistMC>(particles, cGen, occGen, zvtxMC, gtZeroColl); - if (collisions.size() == 0) { if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), - mcCollision.posZ(), cGen); + registryMC.fill(HIST("Events/Centrality/NotFoundEventZvtx"), mcCollision.posZ(), cGen, occGen); } else { - qaregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + registryMC.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ(), occGen); } } + fillHistMC>(particles, mcCollision.posZ(), cGen, occGen); } - void processMCInclusive( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks) - { - processMC(mccollision, collisions, particles, - tracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCInclusive, - "Count MC particles (inclusive)", false); - - void processMCCentFT0C( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks) - { - processMC(mccollision, collisions, - particles, tracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCCentFT0C, - "Count MC particles in FT0C centrality bins", false); - - void processMCCentFT0CVariant1( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks) - { - processMC(mccollision, collisions, - particles, tracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCCentFT0CVariant1, - "Count MC particles in FT0CVariant1 centrality bins", false); - - void processMCCentFT0M( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks) - { - processMC(mccollision, collisions, - particles, tracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCCentFT0M, - "Count MC particles in FT0M centrality bins", false); - - void processMCCentNGlobal( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks) + void processMCInclusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) { - processMC(mccollision, collisions, - particles, tracks); + processMC(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processMCCentNGlobal, - "Count MC particles in NGlobal centrality bins", false); + PROCESS_SWITCH(DndetaMFTPbPb, processMCInclusive, "Count MC particles (inclusive)", false); - void processMCCentMFT( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks) + void processMCCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) { - processMC(mccollision, collisions, - particles, tracks); + processMC(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processMCCentMFT, - "Count MC particles in MFT centrality bins", false); + PROCESS_SWITCH(DndetaMFTPbPb, processMCCentFT0C, "Count MC particles in FT0C centrality bins", false); - PresliceUnsorted perColU = - aod::fwdtrack::bestCollisionId; + PresliceUnsorted perColU = aod::fwdtrack::bestCollisionId; - /// @brief process template function to run on MC truth using - /// aod::BestCollisionsFwd3d tracks template - void processMCwBestTracks( - typename MC::iterator const& mcCollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) + void processMCbest(typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& /*tracks*/, + MftBestTracksLabeled const& besttracks) { - bool gtZeroColl = false; + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + float occGen = -1.; + for (const auto& collision : collisions) { + if (isGoodEvent(collision)) { + float o = getOccupancy(collision, eventCuts.occupancyEstimator); + if (o > occGen) { + occGen = o; + } + } + } float cGen = -1; + if (eventCuts.useGenMult) { + cGen = mcCollision.multMCFT0C(); + } if constexpr (has_reco_cent) { - float crecMin = 105.f; + float crecMin = 999.; for (const auto& collision : collisions) { if (isGoodEvent(collision)) { float c = getRecoCent(collision); @@ -2569,362 +1579,543 @@ struct DndetaMFTPbPb { } } - float occGen = -1.; - for (const auto& collision : collisions) { - if (isGoodEvent(collision)) { - float o = getOccupancy(collision, eventCuts.occupancyEstimator); - if (o > occGen) { - occGen = o; - } - } - } + buildLookupTable(collisions); for (auto const& collision : collisions) { - auto occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - float crec = getRecoCent(collision); - + float occRec = getOccupancy(collision, eventCuts.occupancyEstimator); + float cRec = getRecoCent(collision); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., crec, occrec); + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecAll), cRec, occRec); } else { - registry.fill(HIST("Events/EvtEffGen"), 1., occrec); + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecAll), occRec); + } + if (!isGoodEvent(collision)) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecSel), cRec, occRec); + } else { + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecSel), occRec); + } + if (!collision.has_mcCollision()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecHasMcColl), cRec, occRec); + } else { + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecHasMcColl), occRec); + } + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcRecNoSplitVtx), cRec, occRec); + registryMC.fill(HIST("Events/Centrality/hRecZvtxCent"), collision.posZ(), cRec, occRec); + } else { + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcRecNoSplitVtx), occRec); } - if (isGoodEvent(collision)) { - gtZeroColl = true; - auto z = collision.posZ(); - + auto nATrk = 0; + auto perCollisionASample = besttracks.sliceBy(perColU, collision.globalIndex()); + for (auto const& atrack : perCollisionASample) { if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., crec, occrec); + registryMC.fill(HIST("Tracks/Centrality/hMcTrackStatus"), static_cast(McTrackStatus::kBestTrkAll), cRec, occRec); } else { - registry.fill(HIST("Events/EvtEffGen"), 2., occrec); + registryMC.fill(HIST("Tracks/hMcTrackStatus"), static_cast(McTrackStatus::kBestTrkAll), occRec); + } + if (!isBestTrackSelected(atrack)) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/hMcTrackStatus"), static_cast(McTrackStatus::kBesTrktSel), cRec, occRec); + } else { + registryMC.fill(HIST("Tracks/hMcTrackStatus"), static_cast(McTrackStatus::kBesTrktSel), occRec); + } + const float bestDcaZ = getDCAz(atrack); + auto itrack = atrack.template mfttrack_as(); + if (!isTrackSelected(itrack)) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/hMcTrackStatus"), static_cast(McTrackStatus::kTrkAsBestSel), cRec, occRec); + } else { + registryMC.fill(HIST("Tracks/hMcTrackStatus"), static_cast(McTrackStatus::kTrkAsBestSel), occRec); + } + if (!itrack.has_collision()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/hMcTrackStatus"), static_cast(McTrackStatus::kTrkHasColl), cRec, occRec); + } else { + registryMC.fill(HIST("Tracks/hMcTrackStatus"), static_cast(McTrackStatus::kTrkHasColl), occRec); + } + if (gConf.cfgRemoveReassigned) { + if (itrack.collisionId() != atrack.bestCollisionId()) { + continue; + } } - - auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); - auto perCollisionASample = - besttracks.sliceBy(perColU, collision.globalIndex()); - auto nTrkRec = countBestTracks( - perCollisionSample, perCollisionASample, z, crec, - collision.trackOccupancyInTimeRange()); - if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, - crec, occrec); + registryMC.fill(HIST("Tracks/Centrality/hMcTrackStatus"), static_cast(McTrackStatus::kTrkReassignedRemoved), cRec, occRec); } else { - registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, z, occrec); + registryMC.fill(HIST("Tracks/hMcTrackStatus"), static_cast(McTrackStatus::kTrkReassignedRemoved), occRec); + } + if (itrack.collisionId() >= 0 && itrack.has_mcParticle() && itrack.mcMask() == trackCuts.selMcMask) { + const auto& particle = itrack.template mcParticle_as(); + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + continue; + } + if (eventCuts.useZDiffCut) { + if (std::abs(collision.posZ() - atrack.mcParticle().mcCollision().posZ()) > eventCuts.maxZvtxDiff) { + continue; + } + } + // if (collision.mcCollisionId() != particle.mcCollisionId()) { + // continue; + // } + const int bestRecColl = atrack.bestCollisionId(); + if (!mapMcCollIdPerRecColl.contains(bestRecColl)) { + continue; + } + int64_t mcCollIdRec = mapMcCollIdPerRecColl.find(bestRecColl)->second; + if (mcCollIdRec != particle.mcCollisionId()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/EtaZvtx"), itrack.eta(), collision.posZ(), cRec, occRec); + registryMC.fill(HIST("Tracks/Centrality/PhiEta"), itrack.phi(), itrack.eta(), cRec, occRec); + registryMC.fill(HIST("Tracks/Centrality/NclustersEta"), itrack.nClusters(), itrack.eta(), cRec, occRec); + registryMC.fill(HIST("Tracks/Centrality/DCA3d"), itrack.pt(), itrack.eta(), atrack.bestDCAXY(), bestDcaZ, cRec, occRec); + registryMC.fill(HIST("Tracks/Centrality/TrackAmbDegree"), atrack.ambDegree(), cRec, occRec); + } else { + registryMC.fill(HIST("Tracks/EtaZvtx"), itrack.eta(), collision.posZ(), occRec); + registryMC.fill(HIST("Tracks/PhiEta"), itrack.phi(), itrack.eta(), occRec); + registryMC.fill(HIST("Tracks/NclustersEta"), itrack.nClusters(), itrack.eta(), occRec); + registryMC.fill(HIST("Tracks/DCA3d"), itrack.pt(), itrack.eta(), atrack.bestDCAXY(), bestDcaZ, occRec); + registryMC.fill(HIST("Tracks/TrackAmbDegree"), atrack.ambDegree(), occRec); + } + ++nATrk; } } + if (eventCuts.useZDiffCut) { + if (std::abs(collision.posZ() - mcCollision.posZ()) > eventCuts.maxZvtxDiff) { + continue; + } + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/NtrkZvtxGen"), nATrk, collision.posZ(), cRec, occRec); + registryMC.fill(HIST("Events/Centrality/ZvtxDiff"), collision.posZ() - mcCollision.posZ(), cRec, occRec); + } else { + registryMC.fill(HIST("Events/NtrkZvtxGen"), nATrk, collision.posZ(), occRec); + registryMC.fill(HIST("Events/ZvtxDiff"), collision.posZ() - mcCollision.posZ(), occRec); + } } if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., cGen, occGen); + registryMC.fill(HIST("Events/Centrality/McStatus"), static_cast(McStatus::kMcGenAll), cGen, occGen); } else { - registry.fill(HIST("Events/EvtEffGen"), 3., occGen); + registryMC.fill(HIST("Events/McStatus"), static_cast(McStatus::kMcGenAll), occGen); } - auto zvtxMC = mcCollision.posZ(); auto nCharged = countPart(particles); if constexpr (has_reco_cent) { - registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, zvtxMC, - cGen); + registryMC.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, mcCollision.posZ(), cGen, occGen); } else { - registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); + registryMC.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, mcCollision.posZ(), occGen); } - - fillHistMC>(particles, cGen, occGen, zvtxMC, gtZeroColl); - if (collisions.size() == 0) { if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), - mcCollision.posZ(), cGen); + registryMC.fill(HIST("Events/Centrality/NotFoundEventZvtx"), mcCollision.posZ(), cGen, occGen); } else { - qaregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + registryMC.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ(), occGen); } } + fillHistMC>(particles, mcCollision.posZ(), cGen, occGen); } - void processMCwBestTracksInclusive( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) - { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksInclusive, - "Count MC particles using aod::BestCollisionsFwd3d (inclusive)", - false); - - void processMCwBestTracksCentFT0C( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) - { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentFT0C, - "Count MC particles in FT0C centrality bins using aod::BestCollisionsFwd3d", - false); - - void processMCwBestTracksCentFT0CVariant1( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) - { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentFT0CVariant1, - "Count MC particles in FT0CVariant1 centrality bins using " - "aod::BestCollisionsFwd3d", - false); - - void processMCwBestTracksCentFT0M( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) - { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentFT0M, - "Count MC particles in FT0M centrality bins using aod::BestCollisionsFwd3d", - false); - - void processMCwBestTracksCentNGlobal( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) + void processMCbestInclusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks, + MftBestTracksLabeled const& besttracks) { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); + processMCbest(mccollision, collisions, particles, tracks, besttracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentNGlobal, - "Count MC particles in NGlobal centrality bins using " - "aod::BestCollisionsFwd3d", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processMCbestInclusive, "Count MC particles using aod::BestCollisionsFwd3d (inclusive)", false); - void processMCwBestTracksCentMFT( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) + void processMCbestCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks, + MftBestTracksLabeled const& besttracks) { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); + processMCbest(mccollision, collisions, particles, tracks, besttracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentMFT, - "Count MC particles in MFT centrality bins using aod::BestCollisionsFwd3d", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processMCbestCentFT0C, "Count MC particles in FT0C centrality bins using aod::BestCollisionsFwd3d", false); - using ParticlesI = soa::Join; - Partition primariesI = (aod::mcparticle::flags & (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary && (aod::mcparticle::eta < trackCuts.maxEta) && (aod::mcparticle::eta > trackCuts.minEta); + Preslice filtMcTrkperCol = o2::aod::fwdtrack::collisionId; - // Preslice perMCCol = aod::mcparticle::mcCollisionId; - // - template - void processTrkEffIdxBest( - typename soa::Join const& collisions, - MC const& /*mccollisions*/, ParticlesI const& /*particles*/, - BestTracksMC const& atracks) - { - for (auto const& collision : collisions) { + /// @brief process function to calculate tracking efficiency + template + void processEfficiency(typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) + { + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + auto cRec = -999.; + auto occRec = -999.; + bool gtOneRec = false; + for (const auto& collision : collisions) { if (!isGoodEvent(collision)) { continue; } - if (!collision.has_mcCollision()) { + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { continue; } + gtOneRec = true; + cRec = getRecoCent(collision); + occRec = getOccupancy(collision, eventCuts.occupancyEstimator); + } - float crec = getRecoCent(collision); - auto mcCollision = collision.mcCollision(); - - if (eventCuts.useZDiffCut) { - if (std::abs(collision.posZ() - mcCollision.posZ()) > eventCuts.maxZvtxDiff) { - continue; - } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), cRec, occRec); + if (gtOneRec) { + registryMC.fill(HIST("Events/Centrality/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenRecEvt), cRec, occRec); } - - auto partsPerCol = primariesI->sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); - partsPerCol.bindExternalIndices(&atracks); - for (auto const& particle : partsPerCol) { - if (!isChrgParticle(particle.pdgCode())) { - continue; - } - if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { - continue; - } - - // MC gen - if constexpr (has_reco_cent) { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { - if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffGenBest"), particle.pt(), particle.eta(), crec); - } + } else { + registryMC.fill(HIST("Events/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), occRec); + if (gtOneRec) { + registryMC.fill(HIST("Events/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), occRec); + } + } + for (const auto& particle : particles) { + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + continue; + } + if constexpr (has_reco_cent) { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + registryMC.fill(HIST("Tracks/Centrality/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), cRec, occRec); + if (gtOneRec) { + registryMC.fill(HIST("Tracks/Centrality/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenRecEvt), cRec, occRec); } - } else { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { - if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/hPtEtaEffGenBest"), particle.pt(), particle.eta()); - } + } + } else { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + registryMC.fill(HIST("Tracks/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), occRec); + if (gtOneRec) { + registryMC.fill(HIST("Tracks/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenRecEvt), occRec); } } - // MC rec - if (particle.has_mfttracks()) { - auto iscounted = false; - auto ncnt = 0; - auto relatedTracks = particle.template mfttracks_as(); - for (auto const& track : relatedTracks) { - if (!isBestTrackSelected(track)) { - continue; - } - ++ncnt; - - if constexpr (has_reco_cent) { - if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { - if (!iscounted) { // primaries - if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffPrimBest"), particle.pt(), particle.eta(), crec); - } - iscounted = true; - } - } - if (ncnt > 1) { // secondaries - if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffSecBest"), particle.pt(), particle.eta(), crec); - } - } - } else { - if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { - if (!iscounted) { // primaries - if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/hPtEtaEffPrimBest"), particle.pt(), particle.eta()); - } - iscounted = true; - } - } - if (ncnt > 1) { // secondaries - if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { - qaregistry.fill(HIST("Tracks/hPtEtaEffSecBest"), particle.pt(), particle.eta()); - } - } - } - - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/NmftTrkPerPartBest"), ncnt, crec); - } else { - qaregistry.fill(HIST("Tracks/NmftTrkPerPartBest"), ncnt); - } - - if (relatedTracks.size() > 1) { // duplicates - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffGenDuplBest"), particle.pt(), particle.eta(), crec); - for (auto const& track : relatedTracks) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffDuplBest"), track.pt(), track.eta(), crec); - } - } else { - qaregistry.fill(HIST("Tracks/hPtEtaEffGenDuplBest"), particle.pt(), particle.eta()); - for (auto const& track : relatedTracks) { - qaregistry.fill(HIST("Tracks/hPtEtaEffDuplBest"), track.pt(), track.eta()); - } - } - } + } + } + for (const auto& collision : collisions) { + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffAll), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffAll), occRec); + } + if (!isGoodEvent(collision)) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffSel), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffSel), occRec); + } + if (!collision.has_mcCollision()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffHasMcColl), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffHasMcColl), occRec); + } + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffNoSplitVtx), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffNoSplitVtx), occRec); + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hVtxZRec"), collision.posZ(), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hVtxZRec"), collision.posZ(), occRec); + } + auto perColTrks = tracks.sliceBy(filtMcTrkperCol, collision.globalIndex()); + for (auto const& track : perColTrks) { + if (!isTrackSelected(track)) { + continue; + } + if (track.has_mcParticle() && track.mcMask() == trackCuts.selMcMask) { + const auto& particle = track.template mcParticle_as(); + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + continue; + } + if (collision.mcCollisionId() != particle.mcCollisionId()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/hEffRec"), particle.pt(), particle.phi(), particle.eta(), collision.posZ(), static_cast(RecTrkType::kRecAll), getRecoCent(collision), getOccupancy(collision, eventCuts.occupancyEstimator)); + } else { + registryMC.fill(HIST("Tracks/hEffRec"), particle.pt(), particle.phi(), particle.eta(), collision.posZ(), static_cast(RecTrkType::kRecAll), getOccupancy(collision, eventCuts.occupancyEstimator)); + registryMC.fill(HIST("Tracks/hEtaRes"), particle.eta(), (track.eta() - particle.eta()) / particle.eta(), getOccupancy(collision, eventCuts.occupancyEstimator)); } } else { - // MC FAKES if constexpr (has_reco_cent) { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { - if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffGenFakeBest"), particle.pt(), particle.eta(), crec); - } - } + registryMC.fill(HIST("Tracks/Centrality/hEffRec"), track.pt(), track.phi(), track.eta(), collision.posZ(), static_cast(RecTrkType::kRecFake), getRecoCent(collision), getOccupancy(collision, eventCuts.occupancyEstimator)); } else { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { - if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/hPtEtaEffGenFakeBest"), particle.pt(), particle.eta()); - } - } + registryMC.fill(HIST("Tracks/hEffRec"), track.pt(), track.phi(), track.eta(), collision.posZ(), static_cast(RecTrkType::kRecFake), getOccupancy(collision, eventCuts.occupancyEstimator)); } } } } } - void processTrkEffIdxBestInlusive( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - BestTracksMC const& atracks) + void processEfficiencyInclusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) { - processTrkEffIdxBest(collisions, mccollisions, particles, atracks); + processEfficiency(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffIdxBestInlusive, "Process tracking efficiency best (inclusive, indexed)", false); - void processTrkEffIdxBestCentFT0C( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - BestTracksMC const& atracks) + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyInclusive, "Process efficiencies (inclusive)", false); + + void processEfficiencyCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) { - processTrkEffIdxBest(collisions, mccollisions, particles, atracks); + processEfficiency(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffIdxBestCentFT0C, "Process tracking efficiency best (in FT0C centrality bins, indexed)", false); - - /// @brief process template function to calculate tracking efficiency (indexed - /// as particle-to-MFT-tracks) - template - void processTrkEffIdx( - typename soa::Join const& collisions, - MC const& /*mccollisions*/, ParticlesI const& /*particles*/, - MFTTracksLabeled const& tracks) + + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyCentFT0C, "Process efficiencies in FT0C centrality bins", false); + + /// @brief process function to calculate tracking efficiency based on BestCollisionsFwd3d in FT0C bins + template + void processEfficiencyBest(typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftBestTracksLabeled const& besttracks) { - for (auto const& collision : collisions) { + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + + buildLookupTable(collisions); + + auto cRec = -999.; + auto occRec = -999.; + bool gtOneRec = false; + for (const auto& collision : collisions) { + if (!isGoodEvent(collision)) { + continue; + } + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + gtOneRec = true; + cRec = getRecoCent(collision); + occRec = getOccupancy(collision, eventCuts.occupancyEstimator); + } + + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), cRec, occRec); + if (gtOneRec) { + registryMC.fill(HIST("Events/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenRecEvt), cRec, occRec); + } + } else { + registryMC.fill(HIST("Events/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), occRec); + if (gtOneRec) { + registryMC.fill(HIST("Events/hVtxZGen"), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), occRec); + } + } + + for (const auto& particle : particles) { + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + continue; + } + if constexpr (has_reco_cent) { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + registryMC.fill(HIST("Tracks/Centrality/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), cRec, occRec); + if (gtOneRec) { + registryMC.fill(HIST("Tracks/Centrality/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenRecEvt), cRec, occRec); + } + } + } else { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + registryMC.fill(HIST("Tracks/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenAll), occRec); + if (gtOneRec) { + registryMC.fill(HIST("Tracks/hEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), static_cast(GenTrkType::kGenRecEvt), occRec); + } + } + } + } + + for (const auto& collision : collisions) { + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffAll), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffAll), occRec); + } if (!isGoodEvent(collision)) { continue; } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffSel), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffSel), occRec); + } if (!collision.has_mcCollision()) { continue; } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffHasMcColl), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffHasMcColl), occRec); + } + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hMcEffStatus"), static_cast(McEffStatus::kMcEffNoSplitVtx), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hMcEffStatus"), static_cast(McEffStatus::kMcEffNoSplitVtx), occRec); + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Events/Centrality/hVtxZRec"), collision.posZ(), getRecoCent(collision), cRec, occRec); + } else { + registryMC.fill(HIST("Events/hVtxZRec"), collision.posZ(), occRec); + } - float crec = getRecoCent(collision); - auto occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - auto mcCollision = collision.mcCollision(); + auto perCollisionASample = besttracks.sliceBy(perColU, collision.globalIndex()); + for (auto const& atrack : perCollisionASample) { + if (!isBestTrackSelected(atrack)) { + continue; + } + auto itrack = atrack.template mfttrack_as(); + if (!isTrackSelected(itrack)) { + continue; + } + if (!itrack.has_collision()) { + continue; + } + if (gConf.cfgRemoveReassigned) { + if (itrack.collisionId() != atrack.bestCollisionId()) { + continue; + } + } + if (itrack.collisionId() >= 0 && itrack.has_mcParticle() && itrack.mcMask() == trackCuts.selMcMask) { + const auto& particle = itrack.template mcParticle_as(); + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + continue; + } + if (eventCuts.useZDiffCut) { + if (std::abs(collision.posZ() - atrack.mcParticle().mcCollision().posZ()) > eventCuts.maxZvtxDiff) { + continue; + } + } + const int bestRecColl = atrack.bestCollisionId(); + if (!mapMcCollIdPerRecColl.contains(bestRecColl)) { + continue; + } + int64_t mcCollIdRec = mapMcCollIdPerRecColl.find(bestRecColl)->second; + if (mcCollIdRec != particle.mcCollisionId()) { + continue; + } + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/hEffRec"), particle.pt(), particle.phi(), particle.eta(), collision.posZ(), static_cast(RecTrkType::kRecAll), getRecoCent(collision), getOccupancy(collision, eventCuts.occupancyEstimator)); + } else { + registryMC.fill(HIST("Tracks/hEffRec"), particle.pt(), particle.phi(), particle.eta(), collision.posZ(), static_cast(RecTrkType::kRecAll), getOccupancy(collision, eventCuts.occupancyEstimator)); + registryMC.fill(HIST("Tracks/hEtaRes"), particle.eta(), (itrack.eta() - particle.eta()) / particle.eta(), getOccupancy(collision, eventCuts.occupancyEstimator)); + } + } else { + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/hEffRec"), itrack.pt(), itrack.phi(), itrack.eta(), collision.posZ(), static_cast(RecTrkType::kRecFake), getRecoCent(collision), getOccupancy(collision, eventCuts.occupancyEstimator)); + } else { + registryMC.fill(HIST("Tracks/hEffRec"), itrack.pt(), itrack.phi(), itrack.eta(), collision.posZ(), static_cast(RecTrkType::kRecFake), getOccupancy(collision, eventCuts.occupancyEstimator)); + } + } + } + } + } + + void processEfficiencyBestInclusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftBestTracksLabeled const& besttracks) + { + processEfficiencyBest(mccollision, collisions, particles, besttracks); + } + + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyBestInclusive, "Process tracking efficiency (inclusive, based on BestCollisionsFwd3d)", false); + + void processEfficiencyBestCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftBestTracksLabeled const& besttracks) + { + processEfficiencyBest(mccollision, collisions, particles, besttracks); + } + + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyBestCentFT0C, "Process tracking efficiency (in FT0 centrality bins, based on BestCollisionsFwd3d)", false); + + // Partition primariesIdx = ifnode(nsqrt(aod::mcparticle::vx * aod::mcparticle::vx + aod::mcparticle::vy * aod::mcparticle::vy) > 5.f, false, ncheckbit(aod::mcparticle_v2::storedFlags, (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary)) && (aod::mcparticle::eta < trackCuts.maxEta) && (aod::mcparticle::eta > trackCuts.minEta); - auto partsPerCol = primariesI->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); - partsPerCol.bindExternalIndices(&tracks); + /// @brief process template function to calculate tracking efficiency (indexed as particle-to-MFT-tracks) + template + void processEfficiencyIdx(typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftTracksLabeled const& /*tracks*/) + { + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + for (const auto& collision : collisions) { + if (!isGoodEvent(collision)) { + continue; + } + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + float cRec = getRecoCent(collision); + float occRec = getOccupancy(collision, eventCuts.occupancyEstimator); + auto partsPerCol = particles.sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); for (auto const& particle : partsPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; } - if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + if (collision.mcCollisionId() != particle.mcCollisionId()) { continue; } - // MC gen if constexpr (has_reco_cent) { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta && cutInPhi(particle)) { if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffGen"), particle.pt(), particle.eta(), crec, occrec); + registryMC.fill(HIST("Tracks/Centrality/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxAll), cRec, occRec); } } } else { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta && cutInPhi(particle)) { if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/hPtEtaEffGen"), particle.pt(), particle.eta(), occrec); + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxAll), occRec); } } } @@ -2932,56 +2123,72 @@ struct DndetaMFTPbPb { if (particle.has_mfttracks()) { auto iscounted = false; auto ncnt = 0; - auto relatedTracks = particle.template mfttracks_as(); + auto relatedTracks = particle.template mfttracks_as(); for (auto const& track : relatedTracks) { + if (!isTrackSelected(track)) { + continue; + } + if (track.mcMask() != trackCuts.selMcMask) { + continue; + } ++ncnt; if constexpr (has_reco_cent) { if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { if (!iscounted) { // primaries if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffPrim"), particle.pt(), particle.eta(), crec, occrec); + registryMC.fill(HIST("Tracks/Centrality/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxPrim), cRec, occRec); } iscounted = true; } } + registryMC.fill(HIST("Tracks/Centrality/NmftTrkPerPart"), ncnt, cRec, occRec); if (ncnt > 1) { // secondaries if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffSec"), particle.pt(), particle.eta(), crec, occrec); + registryMC.fill(HIST("Tracks/Centrality/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxSec), cRec, occRec); } } } else { if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { if (!iscounted) { // primaries if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { - qaregistry.fill(HIST("Tracks/hPtEtaEffPrim"), particle.pt(), particle.eta(), occrec); + registryMC.fill(HIST("Tracks/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxPrim), occRec); } iscounted = true; } } + registryMC.fill(HIST("Tracks/NmftTrkPerPart"), ncnt, occRec); if (ncnt > 1) { // secondaries if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { - qaregistry.fill(HIST("Tracks/hPtEtaEffSec"), particle.pt(), particle.eta(), occrec); + registryMC.fill(HIST("Tracks/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxSec), occRec); } } } } - - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/NmftTrkPerPart"), ncnt, crec, occrec); - } else { - qaregistry.fill(HIST("Tracks/NmftTrkPerPart"), ncnt, occrec); - } - if (relatedTracks.size() > 1) { // duplicates if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffGenDupl"), particle.pt(), particle.eta(), crec, occrec); + registryMC.fill(HIST("Tracks/Centrality/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxDupl), cRec, occRec); for (auto const& track : relatedTracks) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEtaEffDupl"), track.pt(), track.eta(), crec, occrec); + registryMC.fill(HIST("Tracks/Centrality/hEffIdxRec"), track.pt(), track.eta(), static_cast(RecIdxTrkType::kRecIdxDupl), cRec, occRec); } } else { - qaregistry.fill(HIST("Tracks/hPtEtaEffGenDupl"), particle.pt(), particle.eta(), occrec); + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxDupl), occRec); for (auto const& track : relatedTracks) { - qaregistry.fill(HIST("Tracks/hPtEtaEffDupl"), track.pt(), track.eta(), occrec); + registryMC.fill(HIST("Tracks/hEffIdxRec"), track.pt(), track.eta(), static_cast(RecIdxTrkType::kRecIdxDupl), occRec); + } + } + } + } else { + // MC FAKES + if constexpr (has_reco_cent) { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/Centrality/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxFake), cRec, occRec); + } + } + } else { + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxFake), occRec); } } } @@ -2990,374 +2197,197 @@ struct DndetaMFTPbPb { } } - void processTrkEffIdxInlusive( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - MFTTracksLabeled const& tracks) + void processEfficiencyIdxInlusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftTracksLabeled const& tracks) { - processTrkEffIdx(collisions, mccollisions, - particles, tracks); + processEfficiencyIdx(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffIdxInlusive, - "Process tracking efficiency (inclusive, indexed)", false); + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyIdxInlusive, "Process tracking efficiency (inclusive, indexed)", false); - void processTrkEffIdxCentFT0C( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - MFTTracksLabeled const& tracks) + void processEfficiencyIdxCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftTracksLabeled const& tracks) { - processTrkEffIdx(collisions, mccollisions, - particles, tracks); + processEfficiencyIdx(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffIdxCentFT0C, - "Process tracking efficiency (in FT0C centrality bins, indexed)", false); - - /// @brief process function to calculate tracking efficiency based - /// on BestCollisionsFwd3d in FT0C bins - template - void processTrkEffBest( - typename soa::Join::iterator const& collision, - MC const& /*mccollisions*/, aod::McParticles const& particles, - MFTTracksLabeled const& tracks, - soa::SmallGroups const& besttracks) + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyIdxCentFT0C, "Process tracking efficiency (in FT0C centrality bins, indexed)", false); + + template + void processEfficiencyIdxBest(typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftBestTracksLabeled const& /*atracks*/) { - if (!isGoodEvent(collision)) { - return; - } - if (!collision.has_mcCollision()) { - return; - } + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); - float crec = getRecoCent(collision); - auto occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - auto mcCollision = collision.mcCollision(); - auto partsPerCol = particles.sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + buildLookupTable(collisions); - for (auto const& particle : partsPerCol) { - if (!isChrgParticle(particle.pdgCode())) { + for (const auto& collision : collisions) { + if (!isGoodEvent(collision)) { continue; } - if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { continue; } - if constexpr (has_reco_cent) { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { - qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), crec, occrec); - } - } else { - if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { - qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ(), occrec); - } - } - } + float cRec = getRecoCent(collision); + float occRec = getOccupancy(collision, eventCuts.occupancyEstimator); - ambiguousTrkIdsMC.reserve(besttracks.size()); - reassignedTrkIdsMC.reserve(besttracks.size()); - - for (auto const& track : besttracks) { - ambiguousTrkIdsMC.emplace_back(track.mfttrackId()); - if (!isBestTrackSelected(track)) { - continue; - } - auto itrack = track.mfttrack_as(); - if (itrack.collisionId() != track.bestCollisionId()) { - reassignedTrkIdsMC.emplace_back(track.mfttrackId()); - } - if (!isTrackSelected(itrack)) { - continue; - } - if (itrack.has_mcParticle() && itrack.mcMask() == trackCuts.selMcMask) { - auto particle = itrack.mcParticle_as(); - if (itrack.eta() > trackCuts.minEta && itrack.eta() < trackCuts.maxEta) { - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestRec"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), crec, occrec); - } else { - qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestRec"), particle.pt(), - particle.phi(), particle.eta(), mcCollision.posZ(), - occrec); - } + auto partsPerCol = particles.sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + for (auto const& particle : partsPerCol) { + if (!isChrgParticle(particle.pdgCode())) { + continue; } - } else { + if (collision.mcCollisionId() != particle.mcCollisionId()) { + continue; + } + // MC gen if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEffBestFakeRec"), itrack.pt(), itrack.phi(), itrack.eta(), mcCollision.posZ(), crec, occrec); + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta && cutInPhi(particle)) { + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/Centrality/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxAll), cRec, occRec); + } + } } else { - qaregistry.fill(HIST("Tracks/hPtEffBestFakeRec"), itrack.pt(), itrack.phi(), itrack.eta(), mcCollision.posZ(), occrec); + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta && cutInPhi(particle)) { + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxAll), occRec); + } + } } - } - } - - for (auto const& track : tracks) { - if (std::find(ambiguousTrkIdsMC.begin(), ambiguousTrkIdsMC.end(), track.globalIndex()) != ambiguousTrkIdsMC.end()) { - continue; - } - if (std::find(reassignedTrkIdsMC.begin(), reassignedTrkIdsMC.end(), track.globalIndex()) != reassignedTrkIdsMC.end()) { - continue; - } - if (!isTrackSelected(track)) { - continue; - } - if (track.has_mcParticle() && track.mcMask() == trackCuts.selMcMask) { - auto particle = track.mcParticle_as(); - if (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestRec"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), crec, occrec); - } else { - qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestRec"), particle.pt(), - particle.phi(), particle.eta(), mcCollision.posZ(), - occrec); + // MC rec + if (particle.has_mfttracks()) { + auto iscounted = false; + auto ncnt = 0; + auto relatedTracks = particle.template mfttracks_as(); + for (auto const& atrack : relatedTracks) { + if (!isBestTrackSelected(atrack)) { + continue; + } + const int bestRecColl = atrack.bestCollisionId(); + if (!mapMcCollIdPerRecColl.contains(bestRecColl)) { + continue; + } + int64_t mcCollIdRec = mapMcCollIdPerRecColl.find(bestRecColl)->second; + if (mcCollIdRec != particle.mcCollisionId()) { + continue; + } + ++ncnt; + if constexpr (has_reco_cent) { + if (atrack.eta() > trackCuts.minEta && atrack.eta() < trackCuts.maxEta) { + if (!iscounted) { // primaries + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/Centrality/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxPrim), cRec, occRec); + } + iscounted = true; + } + } + registryMC.fill(HIST("Tracks/Centrality/NmftTrkPerPart"), ncnt, cRec, occRec); + if (ncnt > 1) { // secondaries + if (atrack.eta() > trackCuts.minEta && atrack.eta() < trackCuts.maxEta) { + registryMC.fill(HIST("Tracks/Centrality/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxSec), cRec, occRec); + } + } + } else { + if (atrack.eta() > trackCuts.minEta && atrack.eta() < trackCuts.maxEta) { + if (!iscounted) { // primaries + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxPrim), occRec); + } + iscounted = true; + } + } + registryMC.fill(HIST("Tracks/NmftTrkPerPart"), ncnt, occRec); + if (ncnt > 1) { // secondaries + if (atrack.eta() > trackCuts.minEta && atrack.eta() < trackCuts.maxEta) { + registryMC.fill(HIST("Tracks/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxSec), occRec); + } + } + } } - } - } else { - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEffBestFakeRec"), track.pt(), track.phi(), track.eta(), mcCollision.posZ(), crec, occrec); - } else { - qaregistry.fill(HIST("Tracks/hPtEffBestFakeRec"), track.pt(), track.phi(), track.eta(), mcCollision.posZ(), occrec); - } - } - } - ambiguousTrkIdsMC.clear(); - ambiguousTrkIdsMC.shrink_to_fit(); - reassignedTrkIdsMC.clear(); - reassignedTrkIdsMC.shrink_to_fit(); - } - - void processTrkEffBestInclusive( - soa::Join::iterator const& collision, - aod::McCollisions const& mccollisions, aod::McParticles const& particles, - MFTTracksLabeled const& tracks, - soa::SmallGroups const& besttracks) - { - processTrkEffBest(collision, mccollisions, - particles, tracks, besttracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffBestInclusive, - "Process tracking efficiency (inclusive, based on BestCollisionsFwd3d)", - false); - - void processTrkEffBestCentFT0C( - soa::Join::iterator const& collision, - aod::McCollisions const& mccollisions, aod::McParticles const& particles, - MFTTracksLabeled const& tracks, - soa::SmallGroups const& besttracks) - { - processTrkEffBest( - collision, mccollisions, particles, tracks, besttracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffBestCentFT0C, - "Process tracking efficiency (in FT0 centrality bins, based " - "on BestCollisionsFwd3d)", - false); - - Preslice filtMcTrkperCol = o2::aod::fwdtrack::collisionId; - - /// @brief process function to calculate MC efficiency and fraction of fake - /// tracks - template - void processEfficiency( - typename soa::Join const& collisions, - MC const& /*mccollisions*/, aod::McParticles const& /*particles*/, - MFTTracksLabeled const& tracks) - { - for (auto const& collision : collisions) { - if (!isGoodEvent(collision)) { - continue; - } - - float crec = getRecoCent(collision); - auto occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - auto mcCollision = collision.mcCollision(); - auto perColTrks = - tracks.sliceBy(filtMcTrkperCol, collision.globalIndex()); - - for (auto const& track : perColTrks) { - if (!isTrackSelected(track)) { - continue; - } - if (track.has_mcParticle() && track.mcMask() == trackCuts.selMcMask) { - auto particle = track.template mcParticle_as(); - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hEffRec"), particle.pt(), - particle.phi(), particle.eta(), mcCollision.posZ(), - crec, occrec); - } else { - qaregistry.fill(HIST("Tracks/hEffRec"), particle.pt(), - particle.phi(), particle.eta(), mcCollision.posZ(), - crec, occrec); + if (relatedTracks.size() > 1) { // duplicates + if constexpr (has_reco_cent) { + registryMC.fill(HIST("Tracks/Centrality/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxDupl), cRec, occRec); + for (auto const& track : relatedTracks) { + registryMC.fill(HIST("Tracks/Centrality/hEffIdxRec"), track.pt(), track.eta(), static_cast(RecIdxTrkType::kRecIdxDupl), cRec, occRec); + } + } else { + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxDupl), occRec); + for (auto const& track : relatedTracks) { + registryMC.fill(HIST("Tracks/hEffIdxRec"), track.pt(), track.eta(), static_cast(RecIdxTrkType::kRecIdxDupl), occRec); + } + } } } else { + // MC FAKES if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hEffFake"), track.pt(), - track.phi(), track.eta(), mcCollision.posZ(), crec, - occrec); + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/Centrality/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxFake), cRec, occRec); + } + } } else { - qaregistry.fill(HIST("Tracks/hEffFake"), track.pt(), track.phi(), - track.eta(), mcCollision.posZ(), crec, occrec); + if (particle.eta() > trackCuts.minEta && particle.eta() < trackCuts.maxEta) { + if (std::abs(mcCollision.posZ()) < eventCuts.maxZvtx) { + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxFake), occRec); + } + } } } } } } - void processEfficiencyInclusive( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, aod::McParticles const& particles, - MFTTracksLabeled const& tracks) + void processEfficiencyIdxBestInlusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftBestTracksLabeled const& atracks) { - processEfficiency(collisions, mccollisions, - particles, tracks); + processEfficiencyIdxBest(mccollision, collisions, particles, atracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyInclusive, - "Process efficiencies (inclusive)", false); + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyIdxBestInlusive, "Process tracking efficiency best (inclusive, indexed)", false); - void processEfficiencyCentFT0C( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, aod::McParticles const& particles, - MFTTracksLabeled const& tracks) + void processEfficiencyIdxBestCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftBestTracksLabeled const& atracks) { - processEfficiency( - collisions, mccollisions, particles, tracks); + processEfficiencyIdxBest(mccollision, collisions, particles, atracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyCentFT0C, - "Process efficiencies in FT0C centrality bins", false); + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyIdxBestCentFT0C, "Process tracking efficiency best (in FT0C centrality bins, indexed)", false); - template - void processCorrelationwBestTracks(typename C::iterator const& collision, FiltMftTracks const& /*tracks*/, soa::SmallGroups const& besttracks) + /// @brief process function to calculate signal loss based on MC + void processMcSgnEvtLossCentFT0C(CollsMCExtraMult::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles) { - if (!isGoodEvent(collision)) { + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + registryMC.fill(HIST("Events/hNchGen"), mcCollision.multMCFT0C(), static_cast(EvtLossType::kGenAll)); + registryMC.fill(HIST("Events/hEvtMcGen"), 0.5); + if (eventCuts.useZVtxCutMC && (std::abs(mcCollision.posZ()) >= eventCuts.maxZvtx)) { return; } - - auto nBestTrks = 0; - for (auto const& atrack : besttracks) { - if (gConf.cfgUseTrackSel && !isBestTrackSelected(atrack)) { - continue; - } - auto itrack = atrack.template mfttrack_as(); - if (itrack.eta() < trackCuts.minEta || itrack.eta() > trackCuts.maxEta) { - continue; - } - if (gConf.cfgUseTrackSel && !isTrackSelected(itrack)) { - continue; - } - nBestTrks++; - } - qaregistry.fill(HIST("Events/hMultMFTvsFT0A"), nBestTrks, collision.multFT0A()); - qaregistry.fill(HIST("Events/hMultMFTvsFT0C"), nBestTrks, collision.multFT0C()); - qaregistry.fill(HIST("Events/hNPVtracksVsFT0C"), collision.multNTracksPV(), collision.multFT0C()); - qaregistry.fill(HIST("Events/hMultMFTvsFV0A"), nBestTrks, collision.multFV0A()); - qaregistry.fill(HIST("Events/hNPVtracksVsMultMFT"), collision.multNTracksPV(), nBestTrks); - } - - void processCorrelationwBestTracksInclusive(CollsCorr::iterator const& collision, FiltMftTracks const& tracks, soa::SmallGroups const& besttracks) - { - processCorrelationwBestTracks(collision, tracks, besttracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processCorrelationwBestTracksInclusive, "Do correlation study based on BestCollisionsFwd3d table", false); - - int getQuadrantPhi(float phi) - { - if (phi >= Czero && phi < Cninety) { - return 0; - } - if (phi >= Cninety && phi <= ConeHeighty) { - return 1; - } - if (phi >= -ConeHeighty && phi < -Cninety) { - return 2; - } - if (phi >= -Cninety && phi < Czero) { - return 3; - } - return -1; - } - - template - int getQuadrantTrack(T const& track) - { - float phi = static_cast(track.phi()) * ConeHeighty / PI; - return getQuadrantPhi(phi); - } - - /// @brief process function to check MFT alignment (based on BestCollisionsFwd3d table) - template - void processAlignment(typename C::iterator const& collision, - FiltMftTracks const& /*tracks*/, - soa::SmallGroups const& besttracks, - CollBCs const& /*bcs*/ - ) - { - auto bc = collision.template foundBC_as(); - if (!isGoodEvent(collision)) { + registryMC.fill(HIST("Events/hEvtMcGen"), 1.5); + // At least one generated primary in MFT acceptance + TVX triggered collisions + if (gConf.cfgUseInelgt0wMFT && !isInelGt0wMft(particles)) { return; } - - if (gConf.cfgDoIR) { - initHadronicRate(bc); - float ir = !gConf.cfgIRSource.value.empty() ? rateFetcher.fetch(ccdb.service, bc.timestamp(), bc.runNumber(), gConf.cfgIRSource, gConf.cfgIRCrashOnNull) * 1.e-3 : -1; - float seconds = bc.timestamp() * 1.e-3 - mMinSeconds; - if (gConf.cfgUseIRCut && (ir < eventCuts.minIR || ir > eventCuts.maxIR)) { // cut on hadronic rate - return; - } - gCurrentHadronicRate->Fill(seconds, ir); - } - - auto z = collision.posZ(); - for (auto const& atrack : besttracks) { - if (!isBestTrackSelected(atrack)) { - continue; - } - auto itrack = atrack.template mfttrack_as(); - if (!isTrackSelected(itrack)) { - continue; - } - - int quadrant = getQuadrantTrack(itrack); - if (quadrant < 0) { - continue; - } - std::get>(hAlignment[0][quadrant][0]["DCA_x_vs_z"])->Fill(z, atrack.bestDCAXY()); - } - } - - void processAlignmentInclusive(Colls::iterator const& collision, - FiltMftTracks const& tracks, - soa::SmallGroups const& besttracks, - CollBCs const& bcs) - { - processAlignment(collision, tracks, besttracks, bcs); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processAlignmentInclusive, "Check MFT alignment using tracks based on BestCollisionsFwd3d table (inclusive)", false); - - /// @brief process function to calculate signal loss based on MC - void processEventAndSignalLossCentFT0C(CollsMCExtraMult::iterator const& mcCollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles) - { - registry.fill(HIST("Events/Centrality/hNRecCollsSigEvtLoss"), 1.f, collisions.size()); - - if (gConf.cfgUseInelgt0 && !mcCollision.isInelGt0()) { - return; - } - if (eventCuts.useZVtxCutMC && (std::abs(mcCollision.posZ()) >= eventCuts.maxZvtx)) { + registryMC.fill(HIST("Events/hEvtMcGen"), 2.5); + if (eventCuts.useInelgt0wTVX && !(mcCollision.multMCFT0C() > 0 && mcCollision.multMCFT0A() > 0)) { return; } + registryMC.fill(HIST("Events/hEvtMcGen"), 3.5); + registryMC.fill(HIST("Events/hNchGen"), mcCollision.multMCFT0C(), static_cast(EvtLossType::kGenSel)); // Evt loss den bool gtZeroColl = false; auto maxNcontributors = -1; - float centrality = -999.f; + float cRec = -999.f; for (auto const& collision : collisions) { if (!isGoodEvent(collision)) { continue; @@ -3365,9 +2395,11 @@ struct DndetaMFTPbPb { if (std::abs(collision.posZ()) >= eventCuts.maxZvtx) { continue; } + registryMC.fill(HIST("Events/hNchGen"), mcCollision.multMCFT0C(), static_cast(EvtLossType::kGenSplit)); + registryMC.fill(HIST("Events/hMultGenVsCentSplit"), getRecoCent(collision), mcCollision.multMCFT0C()); if (maxNcontributors < collision.numContrib()) { maxNcontributors = collision.numContrib(); - centrality = getRecoCent(collision); + cRec = getRecoCent(collision); } gtZeroColl = true; } @@ -3375,22 +2407,21 @@ struct DndetaMFTPbPb { auto perCollMCsample = mcSample->sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto multMCNParticlesEtaMFT = countPart(perCollMCsample); - registry.fill(HIST("Events/Centrality/EvtSigLossStatus"), 1., centrality); - registry.fill(HIST("Events/Centrality/hMultGenVsCent"), centrality, mcCollision.multMCFT0C()); - registry.fill(HIST("Events/Centrality/hMultGenVsCentNParticlesEta05"), centrality, mcCollision.multMCNParticlesEta05()); - registry.fill(HIST("Events/Centrality/hMultGenVsCentNParticlesEtaMFT"), centrality, multMCNParticlesEtaMFT); - - if (collisions.size() == 0) { - registry.fill(HIST("Events/Centrality/EvtSigLossStatus"), 3., centrality); - } + registryMC.fill(HIST("Events/EvtSigLossStatus"), 1., cRec); // Evt split den + registryMC.fill(HIST("Events/hMultGenVsCent"), cRec, mcCollision.multMCFT0C()); + registryMC.fill(HIST("Events/hMultGenVsCentNParticlesEta05"), cRec, mcCollision.multMCNParticlesEta05()); + registryMC.fill(HIST("Events/hMultGenVsCentNParticlesEtaMFT"), cRec, multMCNParticlesEtaMFT); if (gtZeroColl) { - registry.fill(HIST("Events/Centrality/EvtSigLossStatus"), 2., centrality); - registry.fill(HIST("Events/Centrality/hMultGenVsCentRec"), centrality, mcCollision.multMCFT0C()); - registry.fill(HIST("Events/Centrality/hMultGenVsCentRecNParticlesEta05"), centrality, mcCollision.multMCNParticlesEta05()); - registry.fill(HIST("Events/Centrality/hMultGenVsCentRecNParticlesEtaMFT"), centrality, multMCNParticlesEtaMFT); + registryMC.fill(HIST("Events/hNchGen"), mcCollision.multMCFT0C(), static_cast(EvtLossType::kGenRecEvt)); // Evt loss num + registryMC.fill(HIST("Events/EvtSigLossStatus"), 2., cRec); // Evt split num + registryMC.fill(HIST("Events/hMultGenVsCentRec"), cRec, mcCollision.multMCFT0C()); + registryMC.fill(HIST("Events/hMultGenVsCentRecNParticlesEta05"), cRec, mcCollision.multMCNParticlesEta05()); + registryMC.fill(HIST("Events/hMultGenVsCentRecNParticlesEtaMFT"), cRec, multMCNParticlesEtaMFT); + } + if (collisions.size() == 0) { + registryMC.fill(HIST("Events/EvtSigLossStatus"), 3., cRec); } - for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -3398,302 +2429,53 @@ struct DndetaMFTPbPb { if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { continue; } - - float phi = particle.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } - - registry.fill(HIST("Tracks/Centrality/EtaCentVsMultGen_t"), particle.eta(), centrality, mcCollision.multMCFT0C()); - registry.fill(HIST("Tracks/Centrality/EtaGen_t"), particle.eta(), centrality); - + registryMC.fill(HIST("Tracks/hEtaVsNchGen"), particle.eta(), mcCollision.multMCFT0C()); // Sgn loss den if (gtZeroColl) { - float phi = particle.phi(); - o2::math_utils::bringTo02Pi(phi); - if (phi < Czero || TwoPI < phi) { - continue; - } - registry.fill(HIST("Tracks/Centrality/EtaCentVsMultGen"), particle.eta(), centrality, mcCollision.multMCFT0C()); - registry.fill(HIST("Tracks/Centrality/EtaGen"), particle.eta(), centrality); - } - } - } - - PROCESS_SWITCH(DndetaMFTPbPb, processEventAndSignalLossCentFT0C, "Signal/event loss based on MC (in FT0C centrality bins)", false); - - Preslice filtTrkperCol = o2::aod::fwdtrack::collisionId; - - /// @brief process template function for MC QA checks - void processMcQACentFT0C(soa::Join const& collisions, - MFTTracksLabeled const& tracks, - aod::AmbiguousMFTTracks const& atracks, - aod::McCollisions const& mcCollisions, - aod::McParticles const& /*particles*/) - { - for (const auto& collision : collisions) { - float crec = getRecoCent(collision); - auto occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - qaregistry.fill(HIST("Events/Centrality/hRecPerGenColls"), static_cast(collisions.size()) / mcCollisions.size(), crec, occrec); - if (!isGoodEvent(collision)) { - return; - } - - auto trkPerColl = tracks.sliceBy(filtTrkperCol, collision.globalIndex()); - uint ntracks{0u}, nAtracks{0u}; - for (const auto& track : trkPerColl) { - ntracks++; - for (const auto& atrack : atracks) { - if (atrack.mfttrackId() == track.globalIndex()) { - nAtracks++; - break; - } - } + registryMC.fill(HIST("Tracks/hEtaVsNchGenRecEvt"), particle.eta(), mcCollision.multMCFT0C()); // Sgn loss num } - qaregistry.fill(HIST("Tracks/Centrality/hNmftTrks"), ntracks, crec, occrec); - qaregistry.fill(HIST("Tracks/Centrality/hFracAmbiguousMftTrks"), static_cast(nAtracks) / ntracks, crec, occrec); } } - PROCESS_SWITCH(DndetaMFTPbPb, processMcQACentFT0C, "Process MC QA checks (in FT0 centrality bins)", false); + PROCESS_SWITCH(DndetaMFTPbPb, processMcSgnEvtLossCentFT0C, "Process Signal/event loss based on MC (in FT0C centrality bins)", false); - /// @brief process function to check ambiguous tracks - void processCheckAmbiguousMftTracks(aod::Collisions const&, MftTracksWColls const& tracks) - { - for (auto const& track : tracks) { - auto trkCollId = track.has_collision() ? track.collisionId() : -1; - auto ids = track.compatibleCollIds(); - qaregistry.fill(HIST("Tracks/hAmbTrackType"), static_cast(AmbTrkType::kAll)); - if (ids.empty() || (ids.size() == 1 && trkCollId == ids[0])) { - qaregistry.fill(HIST("Tracks/hMftTracksAmbDegreeWithTrivial"), track.compatibleCollIds().size()); - if (ids.empty()) { - qaregistry.fill(HIST("Tracks/hAmbTrackType"), static_cast(AmbTrkType::kOrphan)); - } - if (ids.size() == 1 && trkCollId == ids[0]) { - qaregistry.fill(HIST("Tracks/hAmbTrackType"), static_cast(AmbTrkType::kNonAmb)); - } - continue; - } - qaregistry.fill(HIST("Tracks/hMftTracksAmbDegree"), track.compatibleCollIds().size()); - - if (!track.compatibleCollIds().empty()) { - if (track.compatibleCollIds().size() == 1) { - if (track.collisionId() != track.compatibleCollIds()[0]) { - qaregistry.fill(HIST("Tracks/hAmbTrackType"), static_cast(AmbTrkType::kAmb)); - } else { - qaregistry.fill(HIST("Tracks/hAmbTrackType"), static_cast(AmbTrkType::kNonAmbSame)); - } - } else { - qaregistry.fill(HIST("Tracks/hAmbTrackType"), static_cast(AmbTrkType::kAmbGt1)); - } - } - } - } - - PROCESS_SWITCH(DndetaMFTPbPb, processCheckAmbiguousMftTracks, "Process checks for Ambiguous MFT tracks (inclusive)", false); - - PresliceUnsorted perColBestTrks = aod::fwdtrack::bestCollisionId; - - void processDCAReassocMc( - CollsGenCentFT0CExtra const& collisions, - CollsMCExtra const& mcCollisions, - aod::McParticles const& particles, - BestTracksMC const& besttracks, - MFTTracksLabeled const& /*tracks*/ - ) + template + void processCorrelationwBestTracks(typename C::iterator const& collision, + aod::MFTTracks const& /*tracks*/, + soa::SmallGroups const& besttracks) { - float cGen = -1; - float crecMin = 105.f; - for (const auto& collision : collisions) { - if (isGoodEvent(collision)) { - float c = getRecoCent(collision); - if (c < crecMin) { - crecMin = c; - } - } - } - if (cGen < 0) { - cGen = crecMin; + if (!isGoodEvent(collision)) { + return; } - createMCIds(mcCollisions, collisions, particles); - - registry.fill(HIST("Events/Centrality/EvtGenRecReassoc"), 1., cGen); - - int nNoMC{0}; - for (const auto& collision : collisions) { - auto crec = getRecoCent(collision); - registry.fill(HIST("Events/Centrality/EvtGenRecReassoc"), 2., crec); - if (!isGoodEvent(collision)) { - continue; - } - if (!collision.has_mcCollision()) { - continue; - } - - int64_t recCollId = collision.globalIndex(); - auto itMC = mapMcCollIdPerRecColl.find(recCollId); - if (itMC == mapMcCollIdPerRecColl.end()) { - nNoMC++; + auto nBestTrks = 0; + for (auto const& atrack : besttracks) { + if (gConf.cfgUseTrackSel && !isBestTrackSelected(atrack)) { continue; } - registry.fill(HIST("Events/Centrality/EvtGenRecReassoc"), 3., crec); - if (gConf.cfgRemoveSplitVertex && (!setRecCollSel.contains(collision.globalIndex()))) { + auto itrack = atrack.template mfttrack_as(); + if (itrack.eta() < trackCuts.minEta || itrack.eta() > trackCuts.maxEta) { continue; } - auto mcColl = collision.mcCollision_as(); - if (eventCuts.useZVtxCutMC && (std::abs(mcColl.posZ()) >= eventCuts.maxZvtx)) { + if (gConf.cfgUseTrackSel && !isTrackSelected(itrack)) { continue; } - registry.fill(HIST("Events/Centrality/EvtGenRecReassoc"), 4., crec); - - auto perCollisionASample = besttracks.sliceBy(perColBestTrks, collision.globalIndex()); - for (auto const& atrack : perCollisionASample) { - if (!isBestTrackSelected(atrack)) { - continue; - } - const float bestDcaZ = getDCAz(atrack); - auto itrack = atrack.template mfttrack_as(); - - if (!isTrackSelected(itrack)) { - continue; - } - if (!itrack.has_collision()) { - continue; - } - if (gConf.cfgRemoveReassigned) { - if (itrack.collisionId() != atrack.bestCollisionId()) { - continue; - } - } - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestRec"), itrack.pt(), itrack.eta(), collision.posZ(), atrack.bestDCAXY(), atrack.bestDCAZ(), crec, crec); - - if (itrack.collisionId() >= 0 && itrack.has_mcParticle() && itrack.mcMask() == trackCuts.selMcMask) { - auto particle = itrack.template mcParticle_as(); - if (!isChrgParticle(particle.pdgCode())) { - continue; - } - if (gConf.cfgUseParticleSel && !isParticleSelected(particle)) { - continue; - } - if (eventCuts.useZDiffCut) { - if (std::abs(collision.posZ() - atrack.mcParticle().mcCollision().posZ()) > eventCuts.maxZvtxDiff) { - continue; - } - } - const int bestRecColl = atrack.bestCollisionId(); - auto itMapMcCollIdPerRecColl = mapMcCollIdPerRecColl.find(bestRecColl); - if (itMapMcCollIdPerRecColl == mapMcCollIdPerRecColl.end()) { - continue; - } - const float mcCollIdRec = itMapMcCollIdPerRecColl->second; - // LOGP(info, "\t ---> \t .... \t mcCollIdRec: {} - bestMCCol: {}", mcCollIdRec, bestMCCol); - const auto dcaXtruth(particle.vx() - mcColl.posX()); - const auto dcaYtruth(particle.vy() - mcColl.posY()); - const auto dcaZtruth(particle.vz() - mcColl.posZ()); - auto dcaXYtruth = std::sqrt(dcaXtruth * dcaXtruth + dcaYtruth * dcaYtruth); - - const auto mcId = particle.mcCollisionId(); - if (!mcIds.contains(mcId)) { - continue; - } - auto itRefCent = refCentByMcId.find(mcId); - if (itRefCent == refCentByMcId.end()) { - continue; - } - const float refCent = itRefCent->second; - // auto itGenCent = genCentByMcId.find(mcId); - // if (itGenCent == genCentByMcId.end()) { - // continue; - // } - // const int genCent = itGenCent->second; - - if (atrack.ambDegree() > CintZero) { // all tracks - if (collision.has_mcCollision() && collision.mcCollisionId() == mcId) { // good coll - if (!particle.isPhysicalPrimary()) { // Secondaries (weak decays and material) - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSec"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthSec"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - if (particle.getProcess() == TMCProcess::kPDecay) { // Particles from decay - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecWeak"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } else { // Particles from the material - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecMat"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } - } else { // Primaries - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenPrim"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthPrim"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } - } else { // Wrong collision - if (!particle.isPhysicalPrimary()) { // Secondaries (weak decays and material) - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthSecWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } else { // Primaries - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenPrimWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthPrimWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } - } - if (atrack.ambDegree() == CintOne) { // non-ambiguous - if (collision.has_mcCollision() && collision.mcCollisionId() == mcId) { // good coll - if (!particle.isPhysicalPrimary()) { // Secondaries (weak decays and material) - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecNonAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthSecNonAmb"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - if (particle.getProcess() == TMCProcess::kPDecay) { // Particles from decay - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecWeakNonAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } else { // Particles from the material - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecMatNonAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } - } else { // Primaries - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenPrimNonAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthPrimNonAmb"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } - } else { // Wrong collision - if (!particle.isPhysicalPrimary()) { // Secondaries (weak decays and material) - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecNonAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthSecNonAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } else { // Primaries - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenPrimNonAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthPrimNonAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } - } - } else { // ambiguous - if (collision.has_mcCollision() && mcCollIdRec == mcId) { // good coll - if (!particle.isPhysicalPrimary()) { // Secondaries (weak decays and material) - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthSecAmb"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - if (particle.getProcess() == TMCProcess::kPDecay) { // Particles from decay - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecWeakAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } else { // Particles from the material - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecMatAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } - } else { // Primaries - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenPrimAmb"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthPrimAmb"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } - } else { // wrong collision - if (!particle.isPhysicalPrimary()) { // Secondaries (weak decays and material) - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthSecAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - if (particle.getProcess() == TMCProcess::kPDecay) { // Particles from decay - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecWeakAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } else { // Particles from the material - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenSecMatAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } - } else { // Primaries - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenPrimAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestGenTruthPrimAmbWrongColl"), particle.pt(), particle.eta(), mcColl.posZ(), dcaXYtruth, dcaZtruth, crec, refCent); - } - } - } - } else { // no MC particle - LOGP(debug, "No MC particle for ambiguous itrack, skip..."); - registry.fill(HIST("Tracks/Centrality/THnDCAxyBestRecFake"), itrack.pt(), itrack.eta(), collision.posZ(), atrack.bestDCAXY(), bestDcaZ, crec, refCent); - } - } - } + nBestTrks++; } - LOG(info) << "No MC: " << nNoMC; + registryData.fill(HIST("Events/hMultMFTvsFT0A"), nBestTrks, collision.multFT0A()); + registryData.fill(HIST("Events/hMultMFTvsFT0C"), nBestTrks, collision.multFT0C()); + registryData.fill(HIST("Events/hNPVtracksVsFT0C"), collision.multNTracksPV(), collision.multFT0C()); + registryData.fill(HIST("Events/hMultMFTvsFV0A"), nBestTrks, collision.multFV0A()); + registryData.fill(HIST("Events/hNPVtracksVsMultMFT"), collision.multNTracksPV(), nBestTrks); + } + + void processCorrelationwBestTracksInclusive(CollsCorr::iterator const& collision, + aod::MFTTracks const& tracks, + soa::SmallGroups const& besttracks) + { + processCorrelationwBestTracks(collision, tracks, besttracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processDCAReassocMc, "Process MC DCA checks using re-association information based on BestCollisionsFwd3d table (in FT0C centrality bins)", false); + PROCESS_SWITCH(DndetaMFTPbPb, processCorrelationwBestTracksInclusive, "Process correlation QA based on BestCollisionsFwd3d table", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)