From 9058e9460c60b85b60a40b4d6f48f8255c679ae9 Mon Sep 17 00:00:00 2001 From: Gyula Bencedi Date: Tue, 22 Sep 2026 12:41:41 +0200 Subject: [PATCH 1/2] Cleanup following reassociation checks --- PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx | 3720 ++++++++++------------------ 1 file changed, 1254 insertions(+), 2466 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx index 06bc603dbfd..ff82fecc43d 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,59 +356,29 @@ 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!"); + 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!"); } // registry.add("Events/hRCTSel", "Event accepted if RCT not selected;RCT Status;", {HistType::kTH1F, {{2, 0.5, 2.5}}}); @@ -550,7 +387,13 @@ struct DndetaMFTPbPb { // 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}}}); + // 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 +411,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 +425,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 +686,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 +720,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 +753,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 +762,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 +778,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 +797,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 +821,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 +854,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 +874,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 +885,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 +933,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 +951,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 +972,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 +998,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 +1040,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 +1051,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 +1089,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 +1098,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 +1174,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 +1182,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 +1212,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 +1221,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 +1238,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 +1251,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); - } - - // 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; + 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 @@ -2138,50 +1290,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); + registryData.fill(HIST("Events/Selection"), 1., occ); } - - 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 @@ -2189,169 +1340,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 +1428,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,217 +1585,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) + 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, processMCwBestTracksInclusive, - "Count MC particles using aod::BestCollisionsFwd3d (inclusive)", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processMCbestInclusive, "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) + 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, processMCwBestTracksCentFT0C, - "Count MC particles in FT0C centrality bins using aod::BestCollisionsFwd3d", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processMCbestCentFT0C, "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); - } + Preslice filtMcTrkperCol = o2::aod::fwdtrack::collisionId; - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentFT0CVariant1, - "Count MC particles in FT0CVariant1 centrality bins using " - "aod::BestCollisionsFwd3d", - false); + /// @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 (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { + continue; + } + gtOneRec = true; + cRec = getRecoCent(collision); + occRec = getOccupancy(collision, eventCuts.occupancyEstimator); + } - 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); + 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); + } + } 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); + } + 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 { + if constexpr (has_reco_cent) { + 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 { + registryMC.fill(HIST("Tracks/hEffRec"), track.pt(), track.phi(), track.eta(), collision.posZ(), static_cast(RecTrkType::kRecFake), getOccupancy(collision, eventCuts.occupancyEstimator)); + } + } + } + } } - 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 processEfficiencyInclusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); + processEfficiency(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentNGlobal, - "Count MC particles in NGlobal centrality bins using " - "aod::BestCollisionsFwd3d", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyInclusive, "Process efficiencies (inclusive)", false); - void processMCwBestTracksCentMFT( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - aod::McParticles const& particles, MFTTracksLabeled const& tracks, - FiltBestTracks const& besttracks) + void processEfficiencyCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles, + MftTracksLabeled const& tracks) { - processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); + processEfficiency(mccollision, collisions, particles, tracks); } - PROCESS_SWITCH(DndetaMFTPbPb, processMCwBestTracksCentMFT, - "Count MC particles in MFT centrality bins using aod::BestCollisionsFwd3d", - false); + PROCESS_SWITCH(DndetaMFTPbPb, processEfficiencyCentFT0C, "Process efficiencies in FT0C centrality bins", 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 perMCCol = aod::mcparticle::mcCollisionId; - // - template - void processTrkEffIdxBest( - typename soa::Join const& collisions, - MC const& /*mccollisions*/, ParticlesI const& /*particles*/, - BestTracksMC const& atracks) + /// @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 (!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 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); + } + } - if (eventCuts.useZDiffCut) { - if (std::abs(collision.posZ() - mcCollision.posZ()) > eventCuts.maxZvtxDiff) { + 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); + } + + 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); + } - auto partsPerCol = primariesI->sliceByCached(aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); - partsPerCol.bindExternalIndices(&atracks); + 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); + + /// @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/hPtEtaEffGenBest"), particle.pt(), particle.eta(), crec); + 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/hPtEtaEffGenBest"), particle.pt(), particle.eta()); + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxAll), occRec); } } } @@ -2787,60 +2129,57 @@ 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 (!isBestTrackSelected(track)) { + 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/hPtEtaEffPrimBest"), particle.pt(), particle.eta(), crec); + 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/hPtEtaEffSecBest"), particle.pt(), particle.eta(), crec); + 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/hPtEtaEffPrimBest"), particle.pt(), particle.eta()); + 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/hPtEtaEffSecBest"), particle.pt(), particle.eta()); + registryMC.fill(HIST("Tracks/hEffIdxRec"), particle.pt(), particle.eta(), static_cast(RecIdxTrkType::kRecIdxSec), occRec); } } } - + } + if (relatedTracks.size() > 1) { // duplicates if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/NmftTrkPerPartBest"), ncnt, crec); + 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 { - 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()); - } + 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); } } } @@ -2849,13 +2188,13 @@ struct DndetaMFTPbPb { 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/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) { - qaregistry.fill(HIST("Tracks/hPtEtaEffGenFakeBest"), particle.pt(), particle.eta()); + registryMC.fill(HIST("Tracks/hEffIdxGen"), particle.pt(), particle.eta(), static_cast(GenIdxTrkType::kGenIdxFake), occRec); } } } @@ -2864,67 +2203,65 @@ struct DndetaMFTPbPb { } } - void processTrkEffIdxBestInlusive( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - BestTracksMC const& atracks) + void processEfficiencyIdxInlusive(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftTracksLabeled const& tracks) { - processTrkEffIdxBest(collisions, mccollisions, particles, atracks); + processEfficiencyIdx(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, processEfficiencyIdxInlusive, "Process tracking efficiency (inclusive, indexed)", false); + + void processEfficiencyIdxCentFT0C(CollsMCExtraMult::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticlesIdx const& particles, + MftTracksLabeled const& tracks) { - processTrkEffIdxBest(collisions, mccollisions, particles, atracks); + processEfficiencyIdx(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, 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*/) { - for (auto const& collision : collisions) { + LOGP(debug, "MC col {} has {} reco cols", mcCollision.globalIndex(), collisions.size()); + + buildLookupTable(collisions); + + for (const auto& collision : collisions) { if (!isGoodEvent(collision)) { continue; } - if (!collision.has_mcCollision()) { + if (gConf.cfgRemoveSplitVertex && collision.globalIndex() != mcCollision.bestCollisionIndex()) { continue; } + float cRec = getRecoCent(collision); + float occRec = getOccupancy(collision, eventCuts.occupancyEstimator); - float crec = getRecoCent(collision); - auto occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - auto mcCollision = collision.mcCollision(); - - auto partsPerCol = primariesI->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); - partsPerCol.bindExternalIndices(&tracks); - + 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,432 +2269,131 @@ struct DndetaMFTPbPb { if (particle.has_mfttracks()) { auto iscounted = false; auto ncnt = 0; - auto relatedTracks = particle.template mfttracks_as(); - for (auto const& track : relatedTracks) { + 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 (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { + if (atrack.eta() > trackCuts.minEta && atrack.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); + 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 (track.eta() > trackCuts.minEta && track.eta() < trackCuts.maxEta) { + if (atrack.eta() > trackCuts.minEta && atrack.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); + if (atrack.eta() > trackCuts.minEta && atrack.eta() < trackCuts.maxEta) { + 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); } } } - } - } - } - } - - void processTrkEffIdxInlusive( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - MFTTracksLabeled const& tracks) - { - processTrkEffIdx(collisions, mccollisions, - particles, tracks); - } - - PROCESS_SWITCH(DndetaMFTPbPb, processTrkEffIdxInlusive, - "Process tracking efficiency (inclusive, indexed)", false); - - void processTrkEffIdxCentFT0C( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - MFTTracksLabeled const& tracks) - { - processTrkEffIdx(collisions, mccollisions, - 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) - { - if (!isGoodEvent(collision)) { - return; - } - if (!collision.has_mcCollision()) { - return; - } - - float crec = getRecoCent(collision); - auto occrec = getOccupancy(collision, eventCuts.occupancyEstimator); - auto mcCollision = collision.mcCollision(); - 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)) { - 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); - } - } - } - - 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); - } - } - } else { - if constexpr (has_reco_cent) { - qaregistry.fill(HIST("Tracks/Centrality/hPtEffBestFakeRec"), itrack.pt(), itrack.phi(), itrack.eta(), mcCollision.posZ(), crec, occrec); - } else { - qaregistry.fill(HIST("Tracks/hPtEffBestFakeRec"), itrack.pt(), itrack.phi(), itrack.eta(), mcCollision.posZ(), 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); - } - } - } 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); - } } 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) - { - if (!isGoodEvent(collision)) { - 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*/ - ) + /// @brief process function to calculate signal loss based on MC + void processMcSgnEvtLossCentFT0C(CollsMCExtraMult::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + aod::McParticles const& particles) { - auto bc = collision.template foundBC_as(); - 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; } - - 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()) { + 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 (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 +2401,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 +2413,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 +2435,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); + registryMC.fill(HIST("Tracks/hEtaVsNchGenRecEvt"), particle.eta(), mcCollision.multMCFT0C()); // Sgn loss num } } } - PROCESS_SWITCH(DndetaMFTPbPb, processEventAndSignalLossCentFT0C, "Signal/event loss based on MC (in FT0C centrality bins)", false); - - Preslice filtTrkperCol = o2::aod::fwdtrack::collisionId; + PROCESS_SWITCH(DndetaMFTPbPb, processMcSgnEvtLossCentFT0C, "Process Signal/event loss based on MC (in FT0C centrality bins)", false); - /// @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; - } - } - } - 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); - - /// @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) From 2c331840689bac1dedf89a93a9fe129861442d7f Mon Sep 17 00:00:00 2001 From: Gyula Bencedi Date: Tue, 22 Sep 2026 16:40:50 +0200 Subject: [PATCH 2/2] Revert "[PWGUD] Added process functions for MC closure (#18003)" This reverts commit 40f376b5f47bae9b89ecd1c00a75e9303bf55d71. --- PWGUD/Tasks/sginclusivePhiKstarSD.cxx | 813 ++++---------------------- 1 file changed, 112 insertions(+), 701 deletions(-) diff --git a/PWGUD/Tasks/sginclusivePhiKstarSD.cxx b/PWGUD/Tasks/sginclusivePhiKstarSD.cxx index 29a6fa3a46e..80add1374fa 100644 --- a/PWGUD/Tasks/sginclusivePhiKstarSD.cxx +++ b/PWGUD/Tasks/sginclusivePhiKstarSD.cxx @@ -44,9 +44,6 @@ #include #include -#include - -#include #include #include #include @@ -68,7 +65,7 @@ using o2::aod::sgselector::SingleGapC; struct SginclusivePhiKstarSD { SGSelector sgSelector; - Service pdg{}; + Service pdg; HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; HistogramRegistry rQA{"QA", {}, OutputObjHandlingPolicy::AnalysisObject, true, true}; @@ -517,7 +514,7 @@ struct SginclusivePhiKstarSD { //_____________________________________________________________________________ double cosThetaCollinsSoperFrame(const ROOT::Math::PxPyPzMVector& pair1, const ROOT::Math::PxPyPzMVector& pair2, - const ROOT::Math::PxPyPzMVector& fourPion) + const ROOT::Math::PxPyPzMVector& fourpion) { double halfSqrtSnn = 2680.; double massOfLead208 = 193.6823; @@ -528,7 +525,7 @@ struct SginclusivePhiKstarSD { ROOT::Math::PxPyPzMVector v1 = ROOT::Math::PxPyPzMVector(pair1.Px(), pair1.Py(), pair1.Pz(), pair1.M()); ROOT::Math::PxPyPzMVector v2 = ROOT::Math::PxPyPzMVector(pair2.Px(), pair2.Py(), pair2.Pz(), pair2.M()); - ROOT::Math::PxPyPzMVector v12 = ROOT::Math::PxPyPzMVector(fourPion.Px(), fourPion.Py(), fourPion.Pz(), fourPion.M()); + ROOT::Math::PxPyPzMVector v12 = ROOT::Math::PxPyPzMVector(fourpion.Px(), fourpion.Py(), fourpion.Pz(), fourpion.M()); // Boost to center of mass frame ROOT::Math::Boost boostv12{v12.BoostToCM()}; @@ -543,7 +540,7 @@ struct SginclusivePhiKstarSD { return cosThetaCs; } - double phiCollinsSoperFrame(const ROOT::Math::PxPyPzMVector& pair1, const ROOT::Math::PxPyPzMVector& pair2, const ROOT::Math::PxPyPzMVector& fourPion) + double phiCollinsSoperFrame(const ROOT::Math::PxPyPzMVector& pair1, const ROOT::Math::PxPyPzMVector& pair2, const ROOT::Math::PxPyPzMVector& fourpion) { // Half of the energy per pair of the colliding nucleons. double halfSqrtSnn = 2680.; @@ -555,7 +552,7 @@ struct SginclusivePhiKstarSD { ROOT::Math::PxPyPzMVector v1 = ROOT::Math::PxPyPzMVector(pair1.Px(), pair1.Py(), pair1.Pz(), pair1.M()); ROOT::Math::PxPyPzMVector v2 = ROOT::Math::PxPyPzMVector(pair2.Px(), pair2.Py(), pair2.Pz(), pair2.M()); - ROOT::Math::PxPyPzMVector v12 = ROOT::Math::PxPyPzMVector(fourPion.Px(), fourPion.Py(), fourPion.Pz(), fourPion.M()); + ROOT::Math::PxPyPzMVector v12 = ROOT::Math::PxPyPzMVector(fourpion.Px(), fourpion.Py(), fourpion.Pz(), fourpion.M()); // Boost to center of mass frame ROOT::Math::Boost boostv12{v12.BoostToCM()}; @@ -568,8 +565,8 @@ struct SginclusivePhiKstarSD { ROOT::Math::XYZVectorF yaxisCs{(beam1Cm.Cross(beam2Cm)).Unit()}; ROOT::Math::XYZVectorF xaxisCs{(yaxisCs.Cross(zaxisCs)).Unit()}; - double phiAngle = std::atan2(yaxisCs.Dot(v1Cm), xaxisCs.Dot(v1Cm)); - return phiAngle; + double phi = std::atan2(yaxisCs.Dot(v1Cm), xaxisCs.Dot(v1Cm)); + return phi; } template @@ -592,13 +589,12 @@ struct SginclusivePhiKstarSD { template std::pair selectionEvent(const C& collision, bool fillHist = false) { - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 0); - } // Gapside logic int gapSide = collision.gapSide(); - std::array fitCut = {fv0Cut, ft0aCut, ft0cCut, fddaCut, fddcCut}; + float fitCut[5] = {fv0Cut, ft0aCut, ft0cCut, fddaCut, fddcCut}; int truegapSide = sgSelector.trueGap(collision, fitCut[0], fitCut[1], fitCut[2], zdcCut); if (fillHist) { @@ -608,110 +604,80 @@ struct SginclusivePhiKstarSD { gapSide = truegapSide; - if (gapSide < SingleGapA || gapSide > DoubleGap) { + if (gapSide < SingleGapA || gapSide > DoubleGap) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 1); - } - if (upcflag != -1 && collision.flags() != upcflag) { + if (upcflag != -1 && collision.flags() != upcflag) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 2); - } - if (std::abs(collision.posZ()) > vzCut) { + if (std::abs(collision.posZ()) > vzCut) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 3); - } - if (useOccCut && (std::abs(collision.occupancyInTime()) > confgOccCut)) { + if (useOccCut && (std::abs(collision.occupancyInTime()) > confgOccCut)) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 4); - } - if (useHadronicRateCut && (std::abs(collision.hadronicRate()) > confgHadronicRateMax || std::abs(collision.hadronicRate()) < confgHadronicRateMin)) { + if (useHadronicRateCut && (std::abs(collision.hadronicRate()) > confgHadronicRateMax || std::abs(collision.hadronicRate()) < confgHadronicRateMin)) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 5); - } - if (useTrs && collision.trs() != 1) { + if (useTrs && collision.trs() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 6); - } - if (useTrofs && collision.trofs() != 1) { + if (useTrofs && collision.trofs() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 7); - } - if (useHmpr && collision.hmpr() != 1) { + if (useHmpr && collision.hmpr() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 8); - } - if (useTfb && collision.tfb() != 1) { + if (useTfb && collision.tfb() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 9); - } - if (useItsrofb && collision.itsROFb() != 1) { + if (useItsrofb && collision.itsROFb() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 10); - } - if (useSbp && collision.sbp() != 1) { + if (useSbp && collision.sbp() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 11); - } - if (useZvtxftovpv && collision.zVtxFT0vPV() != 1) { + if (useZvtxftovpv && collision.zVtxFT0vPV() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 12); - } - if (useVtxItsTpc && collision.vtxITSTPC() != 1) { + if (useVtxItsTpc && collision.vtxITSTPC() != 1) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 13); - } - if (!isGoodRCTflag(collision)) { + if (!isGoodRCTflag(collision)) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 14); - } - if (usenumContrib && (collision.numContrib() < mintrack || collision.numContrib() > maxtrack)) { + if (usenumContrib && (collision.numContrib() < mintrack || collision.numContrib() > maxtrack)) return {false, gapSide}; - } - if (fillHist) { + if (fillHist) registry.fill(HIST("hEventCutFlow"), 15); - } return {true, gapSide}; } @@ -783,9 +749,8 @@ struct SginclusivePhiKstarSD { void process(UDCollisionFull const& collision, UDtracksfull const& tracks) { - if (qa) { + if (qa) rQA.fill(HIST("hOcc_before"), collision.occupancyInTime()); - } ROOT::Math::PxPyPzMVector v0; ROOT::Math::PxPyPzMVector v1; @@ -806,9 +771,8 @@ struct SginclusivePhiKstarSD { std::vector parameters = {pvCut, dcazCut, dcaxyCut, tpcChi2Cut, tpcNClsFindableCut, itsChi2Cut, etaCut, ptCut}; auto [eventSelected, gapSide] = selectionEvent(collision, true); - if (!eventSelected) { + if (!eventSelected) return; - } int mult = collision.numContrib(); @@ -822,9 +786,8 @@ struct SginclusivePhiKstarSD { registry.fill(HIST("gap_mult2"), mult); } - if (qa) { + if (qa) rQA.fill(HIST("hOcc_after"), collision.occupancyInTime()); - } int mult0 = 0; int mult1 = 0; @@ -841,9 +804,8 @@ struct SginclusivePhiKstarSD { rQA.fill(HIST("hDcaz_all_before"), track1.dcaZ()); } - if (trackselector(track1, parameters) == 0) { + if (!trackselector(track1, parameters)) continue; - } v0.SetCoordinates(track1.px(), track1.py(), track1.pz(), o2::constants::physics::MassPionCharged); @@ -909,15 +871,13 @@ struct SginclusivePhiKstarSD { } } if (gapSide == SingleGapA) { - if (useMultCut && (mult0 < mintrack || mult0 > maxtrack)) { + if (useMultCut && (mult0 < mintrack || mult0 > maxtrack)) return; - } registry.fill(HIST("mult_0"), mult0); } if (gapSide == SingleGapC) { - if (useMultCut && (mult1 < mintrack || mult1 > maxtrack)) { + if (useMultCut && (mult1 < mintrack || mult1 > maxtrack)) return; - } registry.fill(HIST("mult_1"), mult1); } if (qa) { @@ -937,18 +897,16 @@ struct SginclusivePhiKstarSD { } } for (const auto& [t0, t1] : combinations(tracks, tracks)) { - if ((trackselector(t0, parameters) == 0) || (trackselector(t1, parameters) == 0)) { + if (!trackselector(t0, parameters) || !trackselector(t1, parameters)) continue; - } if (phi && selectionPIDKaon1(t0) && selectionPIDKaon1(t1)) { // Apply kaon hypothesis and create pairs v0.SetCoordinates(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassKaonCharged); v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassKaonCharged); v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { + if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) continue; - } // Opposite sign pairs if (t0.sign() != t1.sign()) { @@ -965,18 +923,16 @@ struct SginclusivePhiKstarSD { // samesignpair if (t0.sign() == t1.sign()) { if (gapSide == SingleGapA) { - if (t0.sign() < 0) { + if (t0.sign() < 0) registry.fill(HIST("os_KK_lsMM_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { + else registry.fill(HIST("os_KK_lsPP_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } } if (gapSide == SingleGapC) { - if (t0.sign() < 0) { + if (t0.sign() < 0) registry.fill(HIST("os_KK_lsMM_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { + else registry.fill(HIST("os_KK_lsPP_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } } if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { registry.fill(HIST("os_KK_ls_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); @@ -997,9 +953,8 @@ struct SginclusivePhiKstarSD { v0.SetCoordinates(rotkaonPx, rotkaonPy, t0.pz(), o2::constants::physics::MassKaonCharged); v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassKaonCharged); v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { + if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) continue; - } if (t0.sign() != t1.sign()) { if (gapSide == SingleGapA) { @@ -1017,19 +972,16 @@ struct SginclusivePhiKstarSD { } } for (const auto& [t0, t1] : combinations(o2::soa::CombinationsFullIndexPolicy(tracks, tracks))) { - if ((trackselector(t0, parameters) == 0) || (trackselector(t1, parameters) == 0)) { + if (!trackselector(t0, parameters) || !trackselector(t1, parameters)) continue; - } - if (t0.globalIndex() == t1.globalIndex()) { + if (t0.globalIndex() == t1.globalIndex()) continue; - } if (rho && selectionPIDProton(t0, useTof, nsigmaTpcCut, nsigmaTofCut) && selectionPIDKaon1(t1)) { v0.SetCoordinates(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassProton); v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassKaonCharged); v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { + if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) continue; - } // Opposite sign pairs if (t0.sign() != t1.sign()) { @@ -1056,15 +1008,13 @@ struct SginclusivePhiKstarSD { } } if (kstar && selectionPIDKaon1(t0) && selectionPIDPion1(t1)) { - if (kaoncut && t0.tpcNSigmaPi() < pionNsigmaCut) { + if (kaoncut && t0.tpcNSigmaPi() < pionNsigmaCut) continue; - } v0.SetCoordinates(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassKaonCharged); v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassPionCharged); v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { + if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) continue; - } // Opposite sign pairs if (t0.sign() != t1.sign()) { @@ -1080,18 +1030,16 @@ struct SginclusivePhiKstarSD { } // same sign pair if (t0.sign() == t1.sign()) { if (gapSide == SingleGapA) { - if (t0.sign() < 0) { + if (t0.sign() < 0) registry.fill(HIST("os_pk_lsMM_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { + else registry.fill(HIST("os_pk_lsPP_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } } if (gapSide == SingleGapC) { - if (t0.sign() < 0) { + if (t0.sign() < 0) registry.fill(HIST("os_pk_lsMM_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { + else registry.fill(HIST("os_pk_lsPP_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } } if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { registry.fill(HIST("os_pk_ls_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); @@ -1111,9 +1059,8 @@ struct SginclusivePhiKstarSD { v0.SetCoordinates(rotkaonPx, rotkaonPy, t0.pz(), o2::constants::physics::MassKaonCharged); v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassPionCharged); v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { + if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) continue; - } if (t0.sign() != t1.sign()) { if (gapSide == SingleGapA) { @@ -1160,9 +1107,8 @@ struct SginclusivePhiKstarSD { registry.fill(HIST("costheta_vs_phi1"), costhetaPair1, phiPair1); } if (static_cast(onlyPionTracksp.size()) != numTwoTracks && static_cast(onlyPionTracksn.size()) != numTwoTracks) { - if (static_cast(onlyPionTracksp.size()) + static_cast(onlyPionTracksn.size()) != numFourTracks) { + if (static_cast(onlyPionTracksp.size()) + static_cast(onlyPionTracksn.size()) != numFourTracks) return; - } const ROOT::Math::PxPyPzMVector& l1 = onlyPionTrackspm.at(0); const ROOT::Math::PxPyPzMVector& l2 = onlyPionTrackspm.at(1); const ROOT::Math::PxPyPzMVector& l3 = onlyPionTrackspm.at(2); @@ -1197,28 +1143,24 @@ struct SginclusivePhiKstarSD { auto [eventSelected1, gapSide1] = selectionEvent(collision1, false); auto [eventSelected2, gapSide2] = selectionEvent(collision2, false); - if (!eventSelected1 || !eventSelected2) { + if (!eventSelected1 || !eventSelected2) continue; - } - if (gapSide1 != gapSide2) { + if (gapSide1 != gapSide2) continue; - } auto posThisColl = posTracks->sliceByCached(aod::udtrack::udCollisionId, collision1.globalIndex(), cache); auto negThisColl = negTracks->sliceByCached(aod::udtrack::udCollisionId, collision2.globalIndex(), cache); // for (auto& [track1, track2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posThisColl, negThisColl))) { for (const auto& [track1, track2] : o2::soa::combinations(posThisColl, negThisColl)) { - if ((trackselector(track1, parameters) == 0) || (trackselector(track2, parameters) == 0)) { + if (!trackselector(track1, parameters) || !trackselector(track2, parameters)) continue; - } if (phi && selectionPIDKaon1(track1) && selectionPIDKaon1(track2)) { v0.SetCoordinates(track1.px(), track1.py(), track1.pz(), o2::constants::physics::MassKaonCharged); v1.SetCoordinates(track2.px(), track2.py(), track2.pz(), o2::constants::physics::MassKaonCharged); v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { + if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) continue; - } // Opposite sign pairs if (track1.sign() != track2.sign()) { if (gapSide1 == SingleGapA) { @@ -1231,19 +1173,16 @@ struct SginclusivePhiKstarSD { } } for (const auto& [track1, track2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posThisColl, negThisColl))) { - if ((trackselector(track1, parameters) == 0) || (trackselector(track2, parameters) == 0)) { + if (!trackselector(track1, parameters) || !trackselector(track2, parameters)) continue; - } - if (track1.globalIndex() == track2.globalIndex()) { + if (track1.globalIndex() == track2.globalIndex()) continue; - } if (kstar && selectionPIDKaon1(track1) && selectionPIDPion1(track2)) { v0.SetCoordinates(track1.px(), track1.py(), track1.pz(), o2::constants::physics::MassKaonCharged); v1.SetCoordinates(track2.px(), track2.py(), track2.pz(), o2::constants::physics::MassPionCharged); v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { + if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) continue; - } // Opposite sign pairs if (track1.sign() != track2.sign()) { if (gapSide1 == SingleGapA) { @@ -1279,16 +1218,14 @@ struct SginclusivePhiKstarSD { ROOT::Math::PxPyPzMVector vkstar; ROOT::Math::PxPyPzMVector vphi; for (const auto& mccollision : mccollisions) { - if (mccollision.generatorsID() != generatedId) { + if (mccollision.generatorsID() != generatedId) continue; - } registry.get(HIST("MC/Stat"))->Fill(0., 1.); // get reconstructed collision which belongs to mccollision auto colSlice = collisions.sliceBy(colPerMcCollision, mccollision.globalIndex()); registry.get(HIST("MC/recCols"))->Fill(colSlice.size(), 1.); - if (reconstruction && colSlice.size() < 1) { + if (reconstruction && colSlice.size() < 1) continue; - } // get McParticles which belong to mccollision auto partSlice = McParts.sliceBy(partPerMcCollision, mccollision.globalIndex()); registry.get(HIST("MC/nParts"))->Fill(partSlice.size(), 1.); @@ -1473,27 +1410,23 @@ struct SginclusivePhiKstarSD { ROOT::Math::PxPyPzMVector vkstar; ROOT::Math::PxPyPzMVector vphi; - if (!collision.has_udMcCollision()) { + if (!collision.has_udMcCollision()) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 1); - if (qaMC) { + if (qaMC) rQA.fill(HIST("hOcc_before_mc"), collision.occupancyInTime()); - } auto mccoll = collision.udMcCollision(); - if (mccoll.generatorsID() != generatedId) { + if (mccoll.generatorsID() != generatedId) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 2); - if (upcflag != -1 && collision.flags() != upcflag) { + if (upcflag != -1 && collision.flags() != upcflag) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 3); - std::array fitCut = {fv0Cut, ft0aCut, ft0cCut, fddaCut, fddcCut}; + float fitCut[5] = {fv0Cut, ft0aCut, ft0cCut, fddaCut, fddcCut}; std::vector parameters = {pvCut, dcazCut, dcaxyCut, tpcChi2Cut, tpcNClsFindableCut, itsChi2Cut, etaCut, ptCut}; int truegapSide = sgSelector.trueGap(collision, fitCut[0], fitCut[1], fitCut[2], zdcCut); registry.get(HIST("Reco/Stat"))->Fill(4.0, 1.); @@ -1563,74 +1496,60 @@ struct SginclusivePhiKstarSD { } } - if (truegapSide != gapsideMC) { + if (truegapSide != gapsideMC) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 4); - if (std::abs(collision.posZ()) > vzCut) { + if (std::abs(collision.posZ()) > vzCut) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 5); - if (useOccCut && (std::abs(collision.occupancyInTime()) > confgOccCut)) { + if (useOccCut && (std::abs(collision.occupancyInTime()) > confgOccCut)) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 6); - if (useHadronicRateCut && (std::abs(collision.hadronicRate()) > confgHadronicRateMax || std::abs(collision.hadronicRate()) < confgHadronicRateMin)) { + if (useHadronicRateCut && (std::abs(collision.hadronicRate()) > confgHadronicRateMax || std::abs(collision.hadronicRate()) < confgHadronicRateMin)) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 7); - if (useTrs && collision.trs() != 1) { + if (useTrs && collision.trs() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 8); - if (useTrofs && collision.trofs() != 1) { + if (useTrofs && collision.trofs() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 9); - if (useHmpr && collision.hmpr() != 1) { + if (useHmpr && collision.hmpr() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 10); - if (useTfb && collision.tfb() != 1) { + if (useTfb && collision.tfb() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 11); - if (useItsrofb && collision.itsROFb() != 1) { + if (useItsrofb && collision.itsROFb() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 12); - if (useSbp && collision.sbp() != 1) { + if (useSbp && collision.sbp() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 13); - if (useZvtxftovpv && collision.zVtxFT0vPV() != 1) { + if (useZvtxftovpv && collision.zVtxFT0vPV() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 14); - if (useVtxItsTpc && collision.vtxITSTPC() != 1) { + if (useVtxItsTpc && collision.vtxITSTPC() != 1) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 15); - if (!isGoodRCTflag(collision)) { + if (!isGoodRCTflag(collision)) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 16); - if (usenumContrib && (collision.numContrib() < mintrack || collision.numContrib() > maxtrack)) { + if (usenumContrib && (collision.numContrib() < mintrack || collision.numContrib() > maxtrack)) return; - } registry.fill(HIST("Reco/hEventCutFlowMC"), 17); if (qaMC) { @@ -1667,9 +1586,8 @@ struct SginclusivePhiKstarSD { } } for (const auto& tr1 : tracks) { - if (!tr1.has_udMcParticle()) { + if (!tr1.has_udMcParticle()) continue; - } auto mcPart1 = tr1.udMcParticle(); if (qaMC) { @@ -1683,9 +1601,8 @@ struct SginclusivePhiKstarSD { registry.get(HIST("Reco/tr_tpcnclfind_1"))->Fill(tr1.tpcNClsFindable(), 1.); registry.get(HIST("Reco/tr_itsChi2NCl_1"))->Fill(tr1.itsChi2NCl(), 1.); - if (trackselector(tr1, parameters) == 0) { + if (!trackselector(tr1, parameters)) continue; - } registry.get(HIST("Reco/tr_dcaz_2"))->Fill(tr1.dcaZ(), 1.); registry.get(HIST("Reco/tr_dcaxy_2"))->Fill(tr1.dcaXY(), 1.); @@ -1738,36 +1655,29 @@ struct SginclusivePhiKstarSD { vr0.SetCoordinates(tr1.px(), tr1.py(), tr1.pz(), o2::constants::physics::MassKaonCharged); registry.get(HIST("Reco/trpt"))->Fill(vr0.Pt(), 1.); registry.get(HIST("Reco/treta_k"))->Fill(vr0.Eta(), 1.); - if (!selectionPIDKaon1(tr1)) { + if (!selectionPIDKaon1(tr1)) continue; - } registry.get(HIST("Reco/trpt_k"))->Fill(vr0.Pt(), 1.); int t2 = 0; for (const auto& tr2 : tracks) { - if (!tr2.has_udMcParticle()) { + if (!tr2.has_udMcParticle()) continue; - } - if (trackselector(tr2, parameters) == 0) { + if (!trackselector(tr2, parameters)) continue; - } t2++; if (t2 > t1) { - if (!selectionPIDKaon1(tr2)) { + if (!selectionPIDKaon1(tr2)) continue; - } vr1.SetCoordinates(tr2.px(), tr2.py(), tr2.pz(), o2::constants::physics::MassKaonCharged); auto mcPart2 = tr2.udMcParticle(); // if (std::abs(mcPart2.globalIndex() - mcPart1.globalIndex()) != 1) // continue; - if (std::abs(mcPart1.pdgCode()) != kKPlus || std::abs(mcPart2.pdgCode()) != kKPlus) { + if (std::abs(mcPart1.pdgCode()) != kKPlus || std::abs(mcPart2.pdgCode()) != kKPlus) continue; - } - if (mcPart1.pdgCode() == mcPart2.pdgCode()) { + if (mcPart1.pdgCode() == mcPart2.pdgCode()) continue; - } - if (!mcPart1.isPhysicalPrimary() || !mcPart2.isPhysicalPrimary()) { + if (!mcPart1.isPhysicalPrimary() || !mcPart2.isPhysicalPrimary()) continue; - } bool flag = false; bool flag1 = false; int gIndex1 = 0; @@ -1779,9 +1689,8 @@ struct SginclusivePhiKstarSD { continue; } vphi.SetCoordinates(mother.px(), mother.py(), mother.pz(), o2::constants::physics::MassPhi); - if (std::abs(vphi.Rapidity()) > 0.5) { + if (std::abs(vphi.Rapidity()) > 0.5) continue; - } flag = true; gIndex1 = mother.globalIndex(); } @@ -1789,9 +1698,8 @@ struct SginclusivePhiKstarSD { for (const auto& mother1 : mcPart1.mothers_as()) { if (std::abs(mother1.pdgCode()) == o2::constants::physics::Pdg::kPhi) { vphi.SetCoordinates(mother1.px(), mother1.py(), mother1.pz(), o2::constants::physics::MassPhi); - if (std::abs(vphi.Rapidity()) > 0.5) { + if (std::abs(vphi.Rapidity()) > 0.5) continue; - } flag1 = true; gIndex2 = mother1.globalIndex(); } @@ -1821,28 +1729,23 @@ struct SginclusivePhiKstarSD { } // KStar for (const auto& [tr1, tr2] : combinations(o2::soa::CombinationsFullIndexPolicy(tracks, tracks))) { - if (!tr1.has_udMcParticle() || !tr2.has_udMcParticle()) { + if (!tr1.has_udMcParticle() || !tr2.has_udMcParticle()) continue; - } - if (!selectionPIDPion1(tr1) || !selectionPIDKaon1(tr2)) { + if (!selectionPIDPion1(tr1) || !selectionPIDKaon1(tr2)) continue; - } // if (tr1.index() == tr2.index()) // continue; // We need to run (0,1), (1,0) pairs as well. but same id pairs are not needed. auto mcPart1 = tr1.udMcParticle(); auto mcPart2 = tr2.udMcParticle(); - if (std::abs(mcPart1.pdgCode()) != kPiPlus || std::abs(mcPart2.pdgCode()) != kKPlus) { + if (std::abs(mcPart1.pdgCode()) != kPiPlus || std::abs(mcPart2.pdgCode()) != kKPlus) continue; - } - if (!mcPart1.isPhysicalPrimary() || !mcPart2.isPhysicalPrimary()) { + if (!mcPart1.isPhysicalPrimary() || !mcPart2.isPhysicalPrimary()) continue; - } // if (std::abs(mcPart2.globalIndex() - mcPart1.globalIndex()) != 1) // continue; - if (tr1.sign() * tr2.sign() > 0) { + if (tr1.sign() * tr2.sign() > 0) continue; - } vr0.SetCoordinates(tr1.px(), tr1.py(), tr1.pz(), o2::constants::physics::MassPionCharged); vr1.SetCoordinates(tr2.px(), tr2.py(), tr2.pz(), o2::constants::physics::MassKaonCharged); @@ -1850,10 +1753,10 @@ struct SginclusivePhiKstarSD { vr1g.SetCoordinates(mcPart2.px(), mcPart2.py(), mcPart2.pz(), o2::constants::physics::MassKaonCharged); vr01g = vr0g + vr1g; vr01 = vr0 + vr1; - if ((trackselector(tr1, parameters) == 0) || (trackselector(tr2, parameters) == 0)) { + if (!trackselector(tr1, parameters) || !trackselector(tr2, parameters)) { registry.get(HIST("Reco/selM_k"))->Fill(vr01.M(), 1.); } - if ((trackselector(tr1, parameters) != 0) && (trackselector(tr2, parameters) != 0)) { + if (trackselector(tr1, parameters) && trackselector(tr2, parameters)) { bool flag = false; bool flag1 = false; int gIndex1 = 0; @@ -1863,9 +1766,8 @@ struct SginclusivePhiKstarSD { if (std::abs(mother.pdgCode()) == o2::constants::physics::Pdg::kK0Star892) { vkstar.SetCoordinates(mother.px(), mother.py(), mother.pz(), o2::constants::physics::MassK0Star892); // registry.get(HIST("MC/accMPtRap_kstar_T"))->Fill(vkstar.M(), vkstar.Pt(), vkstar.Rapidity(), 1.); - if (std::abs(vkstar.Rapidity()) > 0.5) { + if (std::abs(vkstar.Rapidity()) > 0.5) continue; - } flag = true; gIndex1 = mother.globalIndex(); } @@ -1873,9 +1775,8 @@ struct SginclusivePhiKstarSD { for (const auto& mother1 : mcPart2.mothers_as()) { if (std::abs(mother1.pdgCode()) == o2::constants::physics::Pdg::kK0Star892) { vkstar.SetCoordinates(mother1.px(), mother1.py(), mother1.pz(), o2::constants::physics::MassK0Star892); - if (std::abs(vkstar.Rapidity()) > 0.5) { + if (std::abs(vkstar.Rapidity()) > 0.5) continue; - } flag1 = true; gIndex2 = mother1.globalIndex(); } @@ -1914,503 +1815,13 @@ struct SginclusivePhiKstarSD { auto mcPart = track.udMcParticle(); auto pPart = std::sqrt(mcPart.px() * mcPart.px() + mcPart.py() * mcPart.py() + mcPart.pz() * mcPart.pz()); auto pDiff = pTrack - pPart; - registry.get(HIST("Reco/pDiff"))->Fill(pDiff, static_cast(track.isPVContributor()), 1.); + registry.get(HIST("Reco/pDiff"))->Fill(pDiff, track.isPVContributor(), 1.); } else { registry.get(HIST("Reco/pDiff"))->Fill(-5.9, -1, 1.); } } } PROCESS_SWITCH(SginclusivePhiKstarSD, processReco, "Process reconstructed data", true); - - void processSEMC(CC const& collision, TCs const& tracks, aod::UDMcCollisions const& /*mccollisions*/, aod::UDMcParticles const& /* McParts */) - { - - if (!collision.has_udMcCollision()) { - return; - } - - auto mccoll = collision.udMcCollision(); - if (mccoll.generatorsID() != generatedId) { - return; - } - - if (qa) { - rQA.fill(HIST("hOcc_before"), collision.occupancyInTime()); - } - - ROOT::Math::PxPyPzMVector v0; - ROOT::Math::PxPyPzMVector v1; - ROOT::Math::PxPyPzMVector v01; - - ROOT::Math::PxPyPzMVector phiv; - ROOT::Math::PxPyPzMVector phiv1; - - std::vector onlyPionTracksp; - std::vector rawPionTracksp; - - std::vector onlyPionTrackspm; - std::vector rawPionTrackspm; - - std::vector onlyPionTracksn; - std::vector rawPionTracksn; - - std::vector parameters = {pvCut, dcazCut, dcaxyCut, tpcChi2Cut, tpcNClsFindableCut, itsChi2Cut, etaCut, ptCut}; - - auto [eventSelected, gapSide] = selectionEvent(collision, true); - if (!eventSelected) { - return; - } - - int mult = collision.numContrib(); - - if (gapSide == SingleGapA) { - registry.fill(HIST("gap_mult0"), mult); - } - if (gapSide == SingleGapC) { - registry.fill(HIST("gap_mult1"), mult); - } - if (gapSide == DoubleGap) { - registry.fill(HIST("gap_mult2"), mult); - } - - if (qa) { - rQA.fill(HIST("hOcc_after"), collision.occupancyInTime()); - } - - int mult0 = 0; - int mult1 = 0; - int mult2 = 0; - if (qa) { - rQA.fill(HIST("hVertexX"), collision.posX()); - rQA.fill(HIST("hVertexY"), collision.posY()); - rQA.fill(HIST("hVertexZ"), collision.posZ()); - } - - for (const auto& track1 : tracks) { - if (qa) { - rQA.fill(HIST("hDcaxy_all_before"), track1.dcaXY()); - rQA.fill(HIST("hDcaz_all_before"), track1.dcaZ()); - } - - if (trackselector(track1, parameters) == 0) { - continue; - } - - v0.SetCoordinates(track1.px(), track1.py(), track1.pz(), o2::constants::physics::MassPionCharged); - - if (qa) { - rQA.fill(HIST("hDcaxy_all_after"), track1.dcaXY()); - rQA.fill(HIST("hDcaz_all_after"), track1.dcaZ()); - rQA.fill(HIST("hEta_all_after"), v0.Eta()); - } - - if (selectionPIDPion1(track1)) { - onlyPionTrackspm.push_back(v0); - rawPionTrackspm.push_back(track1); - if (track1.sign() == 1) { - onlyPionTracksp.push_back(v0); - rawPionTracksp.push_back(track1); - } - if (track1.sign() == -1) { - onlyPionTracksn.push_back(v0); - rawPionTracksn.push_back(track1); - } - } - if (gapSide == SingleGapA) { - mult0++; - } - if (gapSide == SingleGapC) { - mult1++; - } - if (gapSide == DoubleGap) { - mult2++; - } - - if (qa) { - rQA.fill(HIST("tpc_dedx"), v0.P(), track1.tpcSignal()); - rQA.fill(HIST("tof_beta"), v0.P(), track1.beta()); - rQA.fill(HIST("tof_nsigma_kaon_all"), v0.Pt(), track1.tofNSigmaKa()); - rQA.fill(HIST("tof_nsigma_pion_all"), v0.Pt(), track1.tofNSigmaPi()); - rQA.fill(HIST("tpc_nsigma_kaon_all"), v0.Pt(), track1.tpcNSigmaKa()); - rQA.fill(HIST("tpc_nsigma_pion_all"), v0.Pt(), track1.tpcNSigmaPi()); - - if (selectionPIDKaon1(track1)) { - rQA.fill(HIST("tpc_dedx_kaon"), v0.P(), track1.tpcSignal()); - rQA.fill(HIST("tof_beta_kaon"), v0.P(), track1.beta()); - rQA.fill(HIST("tpc_nsigma_kaon"), v0.Pt(), track1.tpcNSigmaKa()); - rQA.fill(HIST("tof_nsigma_kaon"), v0.Pt(), track1.tofNSigmaKa()); - rQA.fill(HIST("tpc_tof_nsigma_kaon"), track1.tpcNSigmaKa(), track1.tofNSigmaKa()); - rQA.fill(HIST("hEta_ka"), v0.Eta()); - rQA.fill(HIST("hRap_ka"), v0.Rapidity()); - rQA.fill(HIST("hDcaxy_ka"), track1.dcaXY()); - rQA.fill(HIST("hDcaz_ka"), track1.dcaZ()); - } - - if (selectionPIDPion1(track1)) { - rQA.fill(HIST("tpc_dedx_pion"), v0.P(), track1.tpcSignal()); - rQA.fill(HIST("tof_beta_pion"), v0.P(), track1.beta()); - rQA.fill(HIST("tpc_nsigma_pion"), v0.Pt(), track1.tpcNSigmaPi()); - rQA.fill(HIST("tof_nsigma_pion"), v0.Pt(), track1.tofNSigmaPi()); - rQA.fill(HIST("tpc_tof_nsigma_pion"), track1.tpcNSigmaPi(), track1.tofNSigmaPi()); - rQA.fill(HIST("hEta_pi"), v0.Eta()); - rQA.fill(HIST("hRap_pi"), v0.Rapidity()); - rQA.fill(HIST("hDcaxy_pi"), track1.dcaXY()); - rQA.fill(HIST("hDcaz_pi"), track1.dcaZ()); - } - } - } - if (gapSide == SingleGapA) { - if (useMultCut && (mult0 < mintrack || mult0 > maxtrack)) { - return; - } - registry.fill(HIST("mult_0"), mult0); - } - if (gapSide == SingleGapC) { - if (useMultCut && (mult1 < mintrack || mult1 > maxtrack)) { - return; - } - registry.fill(HIST("mult_1"), mult1); - } - if (qa) { - if (gapSide == SingleGapA) { - rQA.fill(HIST("V0A_0"), collision.totalFV0AmplitudeA()); - rQA.fill(HIST("FT0A_0"), collision.totalFT0AmplitudeA()); - rQA.fill(HIST("FT0C_0"), collision.totalFT0AmplitudeC()); - rQA.fill(HIST("ZDC_A_0"), collision.energyCommonZNA()); - rQA.fill(HIST("ZDC_C_0"), collision.energyCommonZNC()); - } - if (gapSide == SingleGapC) { - rQA.fill(HIST("V0A_1"), collision.totalFV0AmplitudeA()); - rQA.fill(HIST("FT0A_1"), collision.totalFT0AmplitudeA()); - rQA.fill(HIST("FT0C_1"), collision.totalFT0AmplitudeC()); - rQA.fill(HIST("ZDC_A_1"), collision.energyCommonZNA()); - rQA.fill(HIST("ZDC_C_1"), collision.energyCommonZNC()); - } - } - for (const auto& [t0, t1] : combinations(tracks, tracks)) { - if ((trackselector(t0, parameters) == 0) || (trackselector(t1, parameters) == 0)) { - continue; - } - - if (phi && selectionPIDKaon1(t0) && selectionPIDKaon1(t1)) { - // Apply kaon hypothesis and create pairs - v0.SetCoordinates(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassKaonCharged); - v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassKaonCharged); - v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { - continue; - } - - // Opposite sign pairs - if (t0.sign() != t1.sign()) { - if (gapSide == SingleGapA) { - registry.fill(HIST("os_KK_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide == SingleGapC) { - registry.fill(HIST("os_KK_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_KK_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - // samesignpair - if (t0.sign() == t1.sign()) { - if (gapSide == SingleGapA) { - if (t0.sign() < 0) { - registry.fill(HIST("os_KK_lsMM_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { - registry.fill(HIST("os_KK_lsPP_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - if (gapSide == SingleGapC) { - if (t0.sign() < 0) { - registry.fill(HIST("os_KK_lsMM_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { - registry.fill(HIST("os_KK_lsPP_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_KK_ls_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - - if (fillRotation) { - for (int nrotbkg = 0; nrotbkg < nBkgRotations; nrotbkg++) { - auto anglestart = confMinRot; - auto angleend = confMaxRot; - auto anglestep = (angleend - anglestart) / (1.0 * (nBkgRotations - 1)); - auto rotangle = anglestart + nrotbkg * anglestep; - registry.fill(HIST("hRotation"), rotangle); - - auto rotkaonPx = t0.px() * std::cos(rotangle) - t0.py() * std::sin(rotangle); - auto rotkaonPy = t0.px() * std::sin(rotangle) + t0.py() * std::cos(rotangle); - - v0.SetCoordinates(rotkaonPx, rotkaonPy, t0.pz(), o2::constants::physics::MassKaonCharged); - v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassKaonCharged); - v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { - continue; - } - - if (t0.sign() != t1.sign()) { - if (gapSide == SingleGapA) { - registry.fill(HIST("os_KK_rot_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide == SingleGapC) { - registry.fill(HIST("os_KK_rot_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_KK_rot_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - } - } - } - } - for (const auto& [t0, t1] : combinations(o2::soa::CombinationsFullIndexPolicy(tracks, tracks))) { - if ((trackselector(t0, parameters) == 0) || (trackselector(t1, parameters) == 0)) { - continue; - } - if (t0.globalIndex() == t1.globalIndex()) { - continue; - } - if (rho && selectionPIDProton(t0, useTof, nsigmaTpcCut, nsigmaTofCut) && selectionPIDKaon1(t1)) { - v0.SetCoordinates(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassProton); - v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassKaonCharged); - v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { - continue; - } - - // Opposite sign pairs - if (t0.sign() != t1.sign()) { - if (gapSide == SingleGapA) { - registry.fill(HIST("os_pp_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide == SingleGapC) { - registry.fill(HIST("os_pp_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_pp_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } // same sign pair - if (t0.sign() == t1.sign()) { - if (gapSide == SingleGapA) { - registry.fill(HIST("os_pp_ls_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide == SingleGapC) { - registry.fill(HIST("os_pp_ls_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_pp_ls_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - } - if (kstar && selectionPIDKaon1(t0) && selectionPIDPion1(t1)) { - if (kaoncut && t0.tpcNSigmaPi() < pionNsigmaCut) { - continue; - } - v0.SetCoordinates(t0.px(), t0.py(), t0.pz(), o2::constants::physics::MassKaonCharged); - v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassPionCharged); - v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { - continue; - } - - // Opposite sign pairs - if (t0.sign() != t1.sign()) { - if (gapSide == SingleGapA) { - registry.fill(HIST("os_pk_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide == SingleGapC) { - registry.fill(HIST("os_pk_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_pk_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } // same sign pair - if (t0.sign() == t1.sign()) { - if (gapSide == SingleGapA) { - if (t0.sign() < 0) { - registry.fill(HIST("os_pk_lsMM_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { - registry.fill(HIST("os_pk_lsPP_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - if (gapSide == SingleGapC) { - if (t0.sign() < 0) { - registry.fill(HIST("os_pk_lsMM_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } else { - registry.fill(HIST("os_pk_lsPP_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_pk_ls_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - if (fillRotation) { - for (int nrotbkg = 0; nrotbkg < nBkgRotations; nrotbkg++) { - auto anglestart = confMinRot; - auto angleend = confMaxRot; - auto anglestep = (angleend - anglestart) / (1.0 * (nBkgRotations - 1)); - auto rotangle = anglestart + nrotbkg * anglestep; - registry.fill(HIST("hRotation"), rotangle); - - auto rotkaonPx = t0.px() * std::cos(rotangle) - t0.py() * std::sin(rotangle); - auto rotkaonPy = t0.px() * std::sin(rotangle) + t0.py() * std::cos(rotangle); - - v0.SetCoordinates(rotkaonPx, rotkaonPy, t0.pz(), o2::constants::physics::MassKaonCharged); - v1.SetCoordinates(t1.px(), t1.py(), t1.pz(), o2::constants::physics::MassPionCharged); - v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { - continue; - } - - if (t0.sign() != t1.sign()) { - if (gapSide == SingleGapA) { - registry.fill(HIST("os_pk_rot_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide == SingleGapC) { - registry.fill(HIST("os_pk_rot_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (exclusive && gapSide == DoubleGap && mult2 == numTwoTracks) { - registry.fill(HIST("os_pk_rot_pT_2"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - } - } - } - } - if (fourpion) { - if (gapSide == DoubleGap && mult2 == numFourTracks) { - ROOT::Math::PxPyPzMVector pair1, pair2, pair3, pair4; - if (static_cast(onlyPionTracksp.size()) == numTwoTracks && static_cast(onlyPionTracksn.size()) == numTwoTracks) { - const ROOT::Math::PxPyPzMVector& k1 = onlyPionTracksp.at(0); - const ROOT::Math::PxPyPzMVector& k2 = onlyPionTracksp.at(1); - const ROOT::Math::PxPyPzMVector& k3 = onlyPionTracksn.at(0); - const ROOT::Math::PxPyPzMVector& k4 = onlyPionTracksn.at(1); - phiv = k1 + k2 + k3 + k4; - pair1 = k1 + k3; - pair2 = k2 + k4; - pair3 = k1 + k4; - pair4 = k2 + k3; - registry.fill(HIST("os_pppp_pT_2"), phiv.M(), phiv.Pt(), phiv.Rapidity()); - registry.fill(HIST("os_pp_vs_pp_mass"), pair1.M(), pair2.M()); - registry.fill(HIST("os_pp_vs_pp_pt"), pair1.Pt(), pair2.Pt()); - auto costhetaPair = cosThetaCollinsSoperFrame(pair1, pair2, phiv); - auto phiPair = 1. * o2::constants::math::PI + phiCollinsSoperFrame(pair1, pair2, phiv); - registry.fill(HIST("phi_dis"), phiPair); - registry.fill(HIST("costheta_dis"), costhetaPair); - registry.fill(HIST("costheta_vs_phi"), costhetaPair, phiPair); - registry.fill(HIST("os_pp_vs_pp_mass1"), pair3.M(), pair4.M()); - registry.fill(HIST("os_pp_vs_pp_pt1"), pair3.Pt(), pair4.Pt()); - auto costhetaPair1 = cosThetaCollinsSoperFrame(pair3, pair4, phiv); - auto phiPair1 = 1. * o2::constants::math::PI + phiCollinsSoperFrame(pair3, pair4, phiv); - registry.fill(HIST("phi_dis1"), phiPair1); - registry.fill(HIST("costheta_dis1"), costhetaPair1); - registry.fill(HIST("costheta_vs_phi1"), costhetaPair1, phiPair1); - } - if (static_cast(onlyPionTracksp.size()) != numTwoTracks && static_cast(onlyPionTracksn.size()) != numTwoTracks) { - if (static_cast(onlyPionTracksp.size()) + static_cast(onlyPionTracksn.size()) != numFourTracks) { - return; - } - const ROOT::Math::PxPyPzMVector& l1 = onlyPionTrackspm.at(0); - const ROOT::Math::PxPyPzMVector& l2 = onlyPionTrackspm.at(1); - const ROOT::Math::PxPyPzMVector& l3 = onlyPionTrackspm.at(2); - const ROOT::Math::PxPyPzMVector& l4 = onlyPionTrackspm.at(3); - phiv1 = l1 + l2 + l3 + l4; - registry.fill(HIST("os_pppp_pT_2_ls"), phiv1.M(), phiv1.Pt(), phiv1.Rapidity()); - } - } - } - } - PROCESS_SWITCH(SginclusivePhiKstarSD, processSEMC, "Process unlike event in MC", false); - - void mixprocessMC(CCs const& collisions, TCs const& /* tracks */, aod::UDMcCollisions const& /*mccollisions*/, aod::UDMcParticles const& /* McParts */) - { - ROOT::Math::PxPyPzMVector v0; - ROOT::Math::PxPyPzMVector v1; - ROOT::Math::PxPyPzMVector v01; - - std::vector parameters = {pvCut, dcazCut, dcaxyCut, tpcChi2Cut, tpcNClsFindableCut, itsChi2Cut, etaCut, ptCut}; - - BinningTypeVertexContributor binningOnPositions{{axisVertex, axisMultiplicityClass}, true}; - - for (auto const& [collision1, collision2] : o2::soa::selfCombinations(binningOnPositions, cfgNoMixedEvents, -1, collisions, collisions)) { - - if (!collision1.has_udMcCollision() || !collision2.has_udMcCollision()) { - return; - } - - auto mccoll1 = collision1.udMcCollision(); - auto mccoll2 = collision2.udMcCollision(); - if (mccoll1.generatorsID() != generatedId || mccoll2.generatorsID() != generatedId) { - return; - } - - auto [eventSelected1, gapSide1] = selectionEvent(collision1, false); - auto [eventSelected2, gapSide2] = selectionEvent(collision2, false); - if (!eventSelected1 || !eventSelected2) { - continue; - } - - if (gapSide1 != gapSide2) { - continue; - } - - auto posThisColl = posTracks->sliceByCached(aod::udtrack::udCollisionId, collision1.globalIndex(), cache); - auto negThisColl = negTracks->sliceByCached(aod::udtrack::udCollisionId, collision2.globalIndex(), cache); - // for (auto& [track1, track2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posThisColl, negThisColl))) { - for (const auto& [track1, track2] : o2::soa::combinations(posThisColl, negThisColl)) { - if ((trackselector(track1, parameters) == 0) || (trackselector(track2, parameters) == 0)) { - continue; - } - if (phi && selectionPIDKaon1(track1) && selectionPIDKaon1(track2)) { - v0.SetCoordinates(track1.px(), track1.py(), track1.pz(), o2::constants::physics::MassKaonCharged); - v1.SetCoordinates(track2.px(), track2.py(), track2.pz(), o2::constants::physics::MassKaonCharged); - v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { - continue; - } - // Opposite sign pairs - if (track1.sign() != track2.sign()) { - if (gapSide1 == SingleGapA) { - registry.fill(HIST("os_KK_mix_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide1 == SingleGapC) { - registry.fill(HIST("os_KK_mix_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - } - } - for (const auto& [track1, track2] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(posThisColl, negThisColl))) { - if ((trackselector(track1, parameters) == 0) || (trackselector(track2, parameters) == 0)) { - continue; - } - if (track1.globalIndex() == track2.globalIndex()) { - continue; - } - if (kstar && selectionPIDKaon1(track1) && selectionPIDPion1(track2)) { - v0.SetCoordinates(track1.px(), track1.py(), track1.pz(), o2::constants::physics::MassKaonCharged); - v1.SetCoordinates(track2.px(), track2.py(), track2.pz(), o2::constants::physics::MassPionCharged); - v01 = v0 + v1; - if (rapiditycut && std::abs(v01.Rapidity()) > rapiditycutvalue) { - continue; - } - // Opposite sign pairs - if (track1.sign() != track2.sign()) { - if (gapSide1 == SingleGapA) { - registry.fill(HIST("os_pk_mix_pT_0"), v01.M(), v01.Rapidity(), v01.Pt()); - } - if (gapSide1 == SingleGapC) { - registry.fill(HIST("os_pk_mix_pT_1"), v01.M(), v01.Rapidity(), v01.Pt()); - } - } - } - } - } - } - PROCESS_SWITCH(SginclusivePhiKstarSD, mixprocessMC, "Process Mixed event in MC", false); }; WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)