diff --git a/PWGMM/Mult/Tasks/CMakeLists.txt b/PWGMM/Mult/Tasks/CMakeLists.txt index 9012d14f2c1..6d2098a29ea 100644 --- a/PWGMM/Mult/Tasks/CMakeLists.txt +++ b/PWGMM/Mult/Tasks/CMakeLists.txt @@ -35,7 +35,7 @@ o2physics_add_dpl_workflow(dndeta-mft COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(dndeta-mft-pbpb - SOURCES dndeta-mft-pbpb.cxx + SOURCES dndetaMFTPbPb.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index d5ca119851c..a0240debe4b 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -1,4 +1,4 @@ -// Copyright 2020-2022 CERN and copyright holders of ALICE O2. +// Copyright 2019-2020 CERN and copyright holders of ALICE O2. // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders. // All rights not expressly granted are reserved. // @@ -9,14 +9,9 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -/// -/// \file dndeta-mft-pbpb.cxx -/// \struct dndeta analysis at forward pseudorapidity -/// \brief Task for calculating dNdeta in Pb-Pb collisions using MFT detector -/// \author Gyula Bencedi -/// \since Nov 2024 -/// @note based on dndeta-mft.cxx -/// +/// \brief Task for calculating dNdeta in Pb-Pb collisions using MFT detector +/// \author Gyula Bencedi, gyula.bencedi@cern.ch +/// \since Nov 2024 #include #include @@ -51,28 +46,22 @@ using namespace o2::framework::expressions; using namespace o2::aod::track; using namespace o2::aod::fwdtrack; -AxisSpec PtAxis = {1001, -0.005, 10.005}; -AxisSpec MultAxis = {701, -0.5, 700.5, "N_{trk}"}; -AxisSpec ZAxis = {60, -30., 30.}; -AxisSpec DeltaZAxis = {61, -6.1, 6.1}; -AxisSpec DCAxyAxis = {500, -1, 50}; -AxisSpec PhiAxis = {629, 0, o2::constants::math::TwoPI, "Rad", "#phi"}; -AxisSpec EtaAxis = {20, -4., -2.}; +AxisSpec ptAxis = {1001, -0.005, 10.005}; +AxisSpec multAxis = {701, -0.5, 700.5, "N_{trk}"}; +AxisSpec zAxis = {60, -30., 30.}; +AxisSpec deltaZAxis = {61, -6.1, 6.1}; +AxisSpec dcaxyAxis = {500, -1, 50}; +AxisSpec phiAxis = {629, 0, o2::constants::math::TwoPI, "Rad", "#phi"}; +AxisSpec etaAxis = {20, -4., -2.}; -struct PseudorapidityDensityMFT { +struct DndetaMFTPbPb { SliceCache cache; // Histogram registry HistogramRegistry registry{ - "registry", - {}, - OutputObjHandlingPolicy::AnalysisObject}; - HistogramRegistry QAregistry{ - "QAregistry", - {}, - OutputObjHandlingPolicy::AnalysisObject, - false, - true}; + "registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry qaregistry{ + "qaregistry", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; // analysis specific conf. Configurable usePhiCut{"usePhiCut", false, "use azimuthal angle cut"}; @@ -81,81 +70,71 @@ struct PseudorapidityDensityMFT { // track selection conf. struct : ConfigurableGroup { - Configurable cfg_eta_min{"cfg_eta_min", -3.6f, ""}; - Configurable cfg_eta_max{"cfg_eta_max", -2.5f, ""}; - Configurable cfg_min_ncluster_mft{"cfg_min_ncluster_mft", 5, - "minimum number of MFT clusters"}; - Configurable cfg_min_pt{"cfg_min_pt", 0., - "minimum pT of the MFT tracks"}; - Configurable cfg_require_ca{ - "cfg_require_ca", false, - "Use Cellular Automaton track-finding algorithm"}; - Configurable cfg_max_dcaxy{"cfg_max_dcaxy", 2.0f, "Cut on dcaXY"}; + Configurable cfgPhiMin{"cfgPhiMin", 0.f, ""}; + Configurable cfgPhiMax{"cfgPhiMax", 6.2832, ""}; + Configurable cfgEtaMin{"cfgEtaMin", -3.6f, ""}; + Configurable cfgEtaMax{"cfgEtaMax", -2.5f, ""}; + Configurable cfgMinNclusterMft{"cfgMinNclusterMft", 5, + "minimum number of MFT clusters"}; + Configurable cfgPtMin{"cfgPtMin", 0., + "minimum pT of the MFT tracks"}; + Configurable cfgRequireCA{"cfgRequireCA", false, + "Use Cellular Automaton track-finding algorithm"}; + Configurable cfgDCAxyMax{"cfgDCAxyMax", 2.0f, "Cut on dcaXY"}; } trkcuts; // event selection conf. Configurable cfgCutZvtx{"cfgCutZvtx", 10.0f, "Cut on z-vtx"}; Configurable cfgCutCent{"cfgCutCent", 80.0f, "Cut on maximum centrality"}; - Configurable useZDiffCut{"useZvtxDiffCut", false, + Configurable useZDiffCut{"useZDiffCut", false, "use Zvtx reco-mc diff. cut"}; - Configurable maxZvtxDiff{ - "maxZvtxDiff", 1.0f, - "max allowed Z vtx difference for reconstruced collisions (cm)"}; - Configurable requireNoCollInTimeRangeStd{ - "requireNoCollInTimeRangeStd", false, - "reject collisions corrupted by the cannibalism, with other collisions " - "within +/- 10 microseconds"}; - Configurable requireNoCollInTimeRangeNarrow{ - "requireNoCollInTimeRangeNarrow", false, - "reject collisions corrupted by the cannibalism, with other collisions " - "within +/- 10 microseconds"}; - ConfigurableAxis OccupancyBins{"OccupancyBins", + Configurable maxZvtxDiff{"maxZvtxDiff", 1.0f, + "max allowed Z vtx difference for reconstruced collisions (cm)"}; + Configurable requireNoCollInTimeRangeStd{"requireNoCollInTimeRangeStd", false, + "reject collisions corrupted by the cannibalism, with other collisions " + "within +/- 10 microseconds"}; + Configurable requireNoCollInTimeRangeNarrow{"requireNoCollInTimeRangeNarrow", false, + "reject collisions corrupted by the cannibalism, with other collisions " + "within +/- 10 microseconds"}; + ConfigurableAxis occupancyBins{"occupancyBins", {VARIABLE_WIDTH, 0.0f, 250.0f, 500.0f, 750.0f, 1000.0f, 1500.0f, 2000.0f, 3000.0f, 4500.0f, 6000.0f, 8000.0f, 10000.0f, 50000.0f}, "Occupancy"}; - Configurable minOccupancy{ - "minOccupancy", -1, "minimum occupancy from neighbouring collisions"}; - Configurable maxOccupancy{ - "maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; - ConfigurableAxis CentBins{ - "CentBins", - {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, - ""}; + Configurable minOccupancy{"minOccupancy", -1, "minimum occupancy from neighbouring collisions"}; + Configurable maxOccupancy{"maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; + ConfigurableAxis centBins{"centBins", + {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, + ""}; Service pdg; /// @brief init function, definition of histograms - void init(InitContext&) - { + void init(InitContext &) { if (static_cast(doprocessDataInclusive) + - static_cast(doprocessDatawBestTracksInclusive) > + static_cast(doprocessDatawBestTracksInclusive) > 1) { - LOGP(fatal, - "Either processDataInclusive OR " - "processDatawBestTracksInclusive should be enabled!"); + LOGP(fatal, "Either processDataInclusive OR " + "processDatawBestTracksInclusive should be enabled!"); } if (static_cast(doprocessDataCent) + - static_cast(doprocessDatawBestTracksCent) > + static_cast(doprocessDatawBestTracksCent) > 1) { - LOGP(fatal, - "Either processDataCent OR processDatawBestTracksCent should " - "be enabled!"); + LOGP(fatal, "Either processDataCent OR processDatawBestTracksCent should " + "be enabled!"); } if (static_cast(doprocessMCInclusive) + - static_cast(doprocessMCwBestTracksInclusive) > + static_cast(doprocessMCwBestTracksInclusive) > 1) { - LOGP(fatal, - "Either processMCInclusive OR processMCwBestTracksInclusive " - "should be enabled!"); + LOGP(fatal, "Either processMCInclusive OR processMCwBestTracksInclusive " + "should be enabled!"); } if (static_cast(doprocessMCCent) + - static_cast(doprocessMCwBestTracksCent) > + static_cast(doprocessMCwBestTracksCent) > 1) { - LOGP(fatal, - "Either processMCCent OR processMCwBestTracksCent should be " - "enabled!"); + LOGP(fatal, "Either processMCCent OR processMCwBestTracksCent should be " + "enabled!"); } auto hev = registry.add("hEvtSel", "hEvtSel", HistType::kTH1F, @@ -176,64 +155,64 @@ struct PseudorapidityDensityMFT { hBcSel->GetXaxis()->SetBinLabel(2, "BCs with collisions"); hBcSel->GetXaxis()->SetBinLabel(3, "BCs with pile-up/splitting"); - AxisSpec CentAxis = {CentBins, "Centrality", "CentralityAxis"}; - AxisSpec OccupancyAxis = {OccupancyBins, "Occupancy", "OccupancyAxis"}; + AxisSpec centAxis = {centBins, "Centrality", "CentralityAxis"}; + AxisSpec occupancyAxis = {occupancyBins, "Occupancy", "occupancyAxis"}; if (doprocessDataInclusive || doprocessDatawBestTracksInclusive) { registry.add({"Events/Selection", ";status;events", {HistType::kTH1F, {{2, 0.5, 2.5}}}}); auto hstat = registry.get(HIST("Events/Selection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); registry.add({"Events/NtrkZvtx", "; N_{trk}; Z_{vtx} (cm);", - {HistType::kTH2F, {MultAxis, ZAxis}}}); + {HistType::kTH2F, {multAxis, zAxis}}}); registry.add({"Tracks/EtaZvtx", "; #eta; Z_{vtx} (cm);", - {HistType::kTH2F, {EtaAxis, ZAxis}}}); + {HistType::kTH2F, {etaAxis, zAxis}}}); registry.add({"Tracks/PhiEta", "; #varphi; #eta;", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}); - QAregistry.add({"Tracks/Chi2Eta", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add({"Tracks/Chi2Eta", "; #chi^{2}; #it{#eta};", {HistType::kTH2F, {{600, 0, 20}, {100, -8, 8}}}}); - QAregistry.add( - {"Tracks/Chi2", "; #chi^{2};", {HistType::kTH1F, {{600, 0, 20}}}}); - QAregistry.add({"Tracks/NclustersEta", + qaregistry.add( + {"Tracks/Chi2", "; #chi^{2};", {HistType::kTH1F, {{600, 0, 20}}}}); + qaregistry.add({"Tracks/NclustersEta", "; nClusters; #eta;", {HistType::kTH2F, {{7, 4, 10}, {100, -8, 8}}}}); - QAregistry.add("Events/Occupancy", "; Z_{vtx} (cm); Occupancy", - HistType::kTH2F, {ZAxis, OccupancyAxis}, false); + qaregistry.add("Events/Occupancy", "; Z_{vtx} (cm); Occupancy", + HistType::kTH2F, {zAxis, occupancyAxis}, false); if (doprocessDatawBestTracksInclusive) { registry.add({"Events/NtrkZvtxBest", "; N_{trk}; Z_{vtx} (cm);", - {HistType::kTH2F, {MultAxis, ZAxis}}}); + {HistType::kTH2F, {multAxis, zAxis}}}); registry.add({"Tracks/EtaZvtxBest", "; #eta; Z_{vtx} (cm);", - {HistType::kTH2F, {EtaAxis, ZAxis}}}); + {HistType::kTH2F, {etaAxis, zAxis}}}); registry.add({"Tracks/PhiEtaBest", "; #varphi; #eta;", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}); - QAregistry.add({"Tracks/NclustersEtaBest", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add({"Tracks/NclustersEtaBest", "; nClusters; #eta;", {HistType::kTH2F, {{7, 4, 10}, {100, -8, 8}}}}); - QAregistry.add({"Tracks/DCAXYPt", + qaregistry.add({"Tracks/DCAXYPt", " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", - {HistType::kTH2F, {PtAxis, DCAxyAxis}}}); - QAregistry.add({"Tracks/DCAXY", + {HistType::kTH2F, {ptAxis, dcaxyAxis}}}); + qaregistry.add({"Tracks/DCAXY", " ; DCA_{XY} (cm)", - {HistType::kTH1F, {DCAxyAxis}}}); - QAregistry.add({"Tracks/ReTracksEtaZvtx", + {HistType::kTH1F, {dcaxyAxis}}}); + qaregistry.add({"Tracks/ReTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH2F, {EtaAxis, ZAxis}}}); - QAregistry.add({"Tracks/ReTracksPhiEta", + {HistType::kTH2F, {etaAxis, zAxis}}}); + qaregistry.add({"Tracks/ReTracksPhiEta", "; #varphi; #eta; tracks", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}); - QAregistry.add({"Tracks/TrackAmbDegree", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add({"Tracks/TrackAmbDegree", " ; N_{coll}^{comp}", {HistType::kTH1F, {{51, -0.5, 50.5}}}}); } @@ -242,77 +221,77 @@ struct PseudorapidityDensityMFT { if (doprocessDataCent || doprocessDatawBestTracksCent) { registry.add({"Events/Centrality/Selection", ";status;centrality;events", - {HistType::kTH2F, {{2, 0.5, 2.5}, CentAxis}}}); + {HistType::kTH2F, {{2, 0.5, 2.5}, centAxis}}}); auto hstat = registry.get(HIST("Events/Centrality/Selection")); - auto* x = hstat->GetXaxis(); + auto *x = hstat->GetXaxis(); x->SetBinLabel(1, "All"); x->SetBinLabel(2, "Selected"); registry.add({"Events/Centrality/NtrkZvtx", "; N_{trk}; Z_{vtx} (cm); centrality", - {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); registry.add({"Tracks/Centrality/EtaZvtx", "; #eta; Z_{vtx} (cm); centrality", - {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); registry.add({"Tracks/Centrality/PhiEta", "; #varphi; #eta; centrality", - {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - QAregistry.add({"Events/Centrality/hcentFT0C", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/hcentFT0C", " ; cent FT0C", - {HistType::kTH1F, {CentAxis}}, + {HistType::kTH1F, {centAxis}}, true}); - QAregistry.add( - {"Tracks/Centrality/Chi2Eta", - "; #chi^{2}; #it{#eta}; centrality", - {HistType::kTH3F, {{600, 0, 20}, {100, -8, 8}, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/Chi2", + qaregistry.add( + {"Tracks/Centrality/Chi2Eta", + "; #chi^{2}; #it{#eta}; centrality", + {HistType::kTH3F, {{600, 0, 20}, {100, -8, 8}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/Chi2", "; #chi^{2}; centrality", - {HistType::kTH2F, {{600, 0, 20}, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/NclustersEta", + {HistType::kTH2F, {{600, 0, 20}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/NclustersEta", "; nClusters; #eta; centrality", - {HistType::kTH3F, {{7, 4, 10}, {100, -8, 8}, CentAxis}}}); - QAregistry.add("Events/Centrality/Occupancy", + {HistType::kTH3F, {{7, 4, 10}, {100, -8, 8}, centAxis}}}); + qaregistry.add("Events/Centrality/Occupancy", "; Z_{vtx} (cm); centrality; Occupancy", HistType::kTH3F, - {ZAxis, CentAxis, OccupancyAxis}, false); - QAregistry.add("Tracks/Centrality/Occupancy", "dndeta occupancy", + {zAxis, centAxis, occupancyAxis}, false); + qaregistry.add("Tracks/Centrality/Occupancy", "dndeta occupancy", HistType::kTHnSparseF, - {ZAxis, CentAxis, EtaAxis, PhiAxis, OccupancyAxis}, false); + {zAxis, centAxis, etaAxis, phiAxis, occupancyAxis}, false); if (doprocessDatawBestTracksCent) { registry.add({"Events/Centrality/NtrkZvtxBest", "; N_{trk}; Z_{vtx} (cm); centrality", - {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); registry.add({"Tracks/Centrality/EtaZvtxBest", "; #eta; Z_{vtx} (cm); centrality", - {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); registry.add({"Tracks/Centrality/PhiEtaBest", "; #varphi; #eta; centrality", - {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - QAregistry.add( - {"Tracks/Centrality/NclustersEtaBest", - "; nClusters; #eta; centrality", - {HistType::kTH3F, {{7, 4, 10}, {100, -8, 8}, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/TrackAmbDegree", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add( + {"Tracks/Centrality/NclustersEtaBest", + "; nClusters; #eta; centrality", + {HistType::kTH3F, {{7, 4, 10}, {100, -8, 8}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/TrackAmbDegree", " ; N_{coll}^{comp}", - {HistType::kTH2F, {{51, -0.5, 50.5}, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/DCAXY", + {HistType::kTH2F, {{51, -0.5, 50.5}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/DCAXY", " ; DCA_{XY} (cm)", - {HistType::kTH2F, {DCAxyAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/DCAXYPt", + {HistType::kTH2F, {dcaxyAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/DCAXYPt", " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", - {HistType::kTH3F, {PtAxis, DCAxyAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/ReTracksEtaZvtx", + {HistType::kTH3F, {ptAxis, dcaxyAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/ReTracksEtaZvtx", "; #eta; #it{z}_{vtx} (cm); tracks", - {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/ReTracksPhiEta", + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/ReTracksPhiEta", "; #varphi; #eta; tracks", - {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - QAregistry.add("Events/Centrality/OccupancyBest", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add("Events/Centrality/OccupancyBest", "; Z_{vtx} (cm); centrality; Occupancy", HistType::kTH3F, - {ZAxis, CentAxis, OccupancyAxis}, false); - QAregistry.add("Tracks/Centrality/OccupancyBest", "dndeta occupancy", + {zAxis, centAxis, occupancyAxis}, false); + qaregistry.add("Tracks/Centrality/OccupancyBest", "dndeta occupancy", HistType::kTHnSparseF, - {ZAxis, CentAxis, EtaAxis, PhiAxis, OccupancyAxis}, + {zAxis, centAxis, etaAxis, phiAxis, occupancyAxis}, false); } } @@ -322,195 +301,194 @@ struct PseudorapidityDensityMFT { ";status;events", {HistType::kTH1F, {{3, 0.5, 3.5}}}}); auto heff = registry.get(HIST("Events/EvtEffGen")); - auto* x = heff->GetXaxis(); + auto *x = heff->GetXaxis(); x->SetBinLabel(1, "All reconstructed"); x->SetBinLabel(2, "Selected reconstructed"); x->SetBinLabel(3, "All generated"); registry.add({"Events/NtrkZvtxGen_t", "; N_{trk}; Z_{vtx} (cm);", - {HistType::kTH2F, {MultAxis, ZAxis}}}); + {HistType::kTH2F, {multAxis, zAxis}}}); registry.add({"Events/NtrkZvtxGen", "; N_{trk}; Z_{vtx} (cm);", - {HistType::kTH2F, {MultAxis, ZAxis}}}); + {HistType::kTH2F, {multAxis, zAxis}}}); registry.add({"Tracks/EtaZvtxGen", "; #eta; Z_{vtx} (cm);", - {HistType::kTH2F, {EtaAxis, ZAxis}}}); + {HistType::kTH2F, {etaAxis, zAxis}}}); registry.add({"Tracks/PhiEtaGen", "; #varphi; #eta;", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}); + {HistType::kTH2F, {phiAxis, etaAxis}}}); registry.add({"Tracks/EtaZvtxGen_t", "; #eta; Z_{vtx} (cm);", - {HistType::kTH2F, {EtaAxis, ZAxis}}}); + {HistType::kTH2F, {etaAxis, zAxis}}}); registry.add({"Tracks/PhiEtaGen_t", "; #varphi; #eta;", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}); - QAregistry.add({"Events/NotFoundEventZvtx", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add({"Events/NotFoundEventZvtx", " ; #it{z}_{vtx} (cm)", - {HistType::kTH1F, {ZAxis}}}); - QAregistry.add({"Events/ZvtxDiff", + {HistType::kTH1F, {zAxis}}}); + qaregistry.add({"Events/ZvtxDiff", " ; Z_{rec} - Z_{gen} (cm)", - {HistType::kTH1F, {DeltaZAxis}}}); - QAregistry.add( - {"Events/SplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); + {HistType::kTH1F, {deltaZAxis}}}); + qaregistry.add( + {"Events/SplitMult", " ; N_{gen}", {HistType::kTH1F, {multAxis}}}); } if (doprocessMCCent || doprocessMCwBestTracksCent) { registry.add({"Events/Centrality/EvtEffGen", ";status;events", - {HistType::kTH2F, {{3, 0.5, 3.5}, CentAxis}}}); + {HistType::kTH2F, {{3, 0.5, 3.5}, centAxis}}}); auto heff = registry.get(HIST("Events/Centrality/EvtEffGen")); - auto* x = heff->GetXaxis(); + auto *x = heff->GetXaxis(); x->SetBinLabel(1, "All reconstructed"); x->SetBinLabel(2, "Selected reconstructed"); x->SetBinLabel(3, "All generated"); registry.add({"Events/Centrality/NtrkZvtxGen_t", "; N_{trk}; Z_{vtx} (cm);", - {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); registry.add({"Events/Centrality/NtrkZvtxGen", "; N_{trk}; Z_{vtx} (cm);", - {HistType::kTH3F, {MultAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); registry.add({"Events/Centrality/hRecCent", "Events/Centrality/hRecCent", - {HistType::kTH1F, {CentAxis}}}); + {HistType::kTH1F, {centAxis}}}); registry.add({"Events/Centrality/hRecZvtxCent", "Events/Centrality/hRecZvtxCent", - {HistType::kTH2F, {ZAxis, CentAxis}}}); + {HistType::kTH2F, {zAxis, centAxis}}}); registry.add({"Tracks/Centrality/EtaZvtxGen", "; #eta; Z_{vtx} (cm);", - {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); registry.add({"Tracks/Centrality/PhiEtaGen", "; #varphi; #eta;", - {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); registry.add({"Tracks/Centrality/EtaZvtxGen_t", "; #eta; Z_{vtx} (cm);", - {HistType::kTH3F, {EtaAxis, ZAxis, CentAxis}}}); + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); registry.add({"Tracks/Centrality/PhiEtaGen_t", "; #varphi; #eta;", - {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - QAregistry.add({"Events/Centrality/NotFoundEventZvtx", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/NotFoundEventZvtx", " ; #it{z}_{vtx} (cm)", - {HistType::kTH2F, {ZAxis, CentAxis}}}); - QAregistry.add({"Events/Centrality/ZvtxDiff", + {HistType::kTH2F, {zAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/ZvtxDiff", " ; Z_{rec} - Z_{gen} (cm)", - {HistType::kTH2F, {DeltaZAxis, CentAxis}}}); - QAregistry.add({"Events/Centrality/SplitMult", + {HistType::kTH2F, {deltaZAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/SplitMult", " ; N_{gen}", - {HistType::kTH2F, {MultAxis, CentAxis}}}); + {HistType::kTH2F, {multAxis, centAxis}}}); } if (doprocessTrkEffIdxInlusive) { - QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffGen", - "hPtPhiEtaZvtxEffGen", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); - QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffRec", - "hPtPhiEtaZvtxEffRec", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); - QAregistry.add({"Tracks/hPhiEtaDuplicates", + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffRec", + "hPtPhiEtaZvtxEffRec", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add({"Tracks/hPhiEtaDuplicates", " ; p_{T} (GeV/c);", - {HistType::kTH2F, {PhiAxis, EtaAxis}}}); - QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffDuplicates", - "hPtPhiEtaZvtxEffDuplicates", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); - QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffGenDuplicates", - "hPtPhiEtaZvtxEffGenDuplicates", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); - QAregistry.add({"Tracks/NmftTrkPerPart", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffDuplicates", + "hPtPhiEtaZvtxEffDuplicates", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffGenDuplicates", + "hPtPhiEtaZvtxEffGenDuplicates", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add({"Tracks/NmftTrkPerPart", "; #it{N}_{mft tracks per particle};", {HistType::kTH1F, {{200, -0.5, 200.}}}}); } if (doprocessTrkEffIdxCent) { - QAregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffGen", + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffGen", "hPtPhiEtaZvtxEffGen", {HistType::kTHnSparseF, - {PtAxis, PhiAxis, EtaAxis, ZAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffRec", + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffRec", "hPtPhiEtaZvtxEffRec", {HistType::kTHnSparseF, - {PtAxis, PhiAxis, EtaAxis, ZAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/hPhiEtaDuplicates", + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPhiEtaDuplicates", " ; p_{T} (GeV/c);", - {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates", "hPtPhiEtaZvtxEffDuplicates", {HistType::kTHnSparseF, - {PtAxis, PhiAxis, EtaAxis, ZAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates", + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates", "hPtPhiEtaZvtxEffGenDuplicates", {HistType::kTHnSparseF, - {PtAxis, PhiAxis, EtaAxis, ZAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/NmftTrkPerPart", + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/NmftTrkPerPart", "; #it{N}_{mft tracks per particle};", - {HistType::kTH2F, {{200, -0.5, 200.}, CentAxis}}}); + {HistType::kTH2F, {{200, -0.5, 200.}, centAxis}}}); } if (doprocessTrkEffBestInclusive) { - QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffBestGen", - "hPtPhiEtaZvtxEffGen", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); - QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffBestRec", - "hPtPhiEtaZvtxEffRec", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); - QAregistry.add({"Tracks/hPtEffBestFakeRec", + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffBestGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffBestRec", + "hPtPhiEtaZvtxEffRec", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add({"Tracks/hPtEffBestFakeRec", " ; p_{T} (GeV/c);", - {HistType::kTH1F, {PtAxis}}}); + {HistType::kTH1F, {ptAxis}}}); } if (doprocessTrkEffBestCent) { - QAregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffBestGen", + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffBestGen", "hPtPhiEtaZvtxEffGen", {HistType::kTHnSparseF, - {PtAxis, PhiAxis, EtaAxis, ZAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffBestRec", + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffBestRec", "hPtPhiEtaZvtxEffRec", {HistType::kTHnSparseF, - {PtAxis, PhiAxis, EtaAxis, ZAxis, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/hPtEffBestFakeRec", + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtEffBestFakeRec", " ; p_{T} (GeV/c);", - {HistType::kTH2F, {PtAxis, CentAxis}}}); + {HistType::kTH2F, {ptAxis, centAxis}}}); } if (doprocessMcQAInclusive) { - QAregistry.add({"Events/hRecPerGenColls", + qaregistry.add({"Events/hRecPerGenColls", "; #it{N}_{reco collisions} / #it{N}_{gen collisions};", {HistType::kTH1F, {{200, 0., 2.}}}}); - QAregistry.add({"Tracks/hNmftTrks", + qaregistry.add({"Tracks/hNmftTrks", "; #it{N}_{mft tracks};", {HistType::kTH1F, {{200, -0.5, 200.}}}}); - QAregistry.add({"Tracks/hFracAmbiguousMftTrks", + qaregistry.add({"Tracks/hFracAmbiguousMftTrks", "; #it{N}_{ambiguous tracks} / #it{N}_{tracks};", {HistType::kTH1F, {{100, 0., 1.}}}}); } if (doprocessMcQACent) { - QAregistry.add( - {"Events/Centrality/hRecPerGenColls", - "; #it{N}_{reco collisions} / #it{N}_{gen collisions}; centrality", - {HistType::kTH2F, {{200, 0., 2.}, CentAxis}}}); - QAregistry.add({"Tracks/Centrality/hNmftTrks", + qaregistry.add( + {"Events/Centrality/hRecPerGenColls", + "; #it{N}_{reco collisions} / #it{N}_{gen collisions}; centrality", + {HistType::kTH2F, {{200, 0., 2.}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hNmftTrks", "; #it{N}_{mft tracks}; centrality", - {HistType::kTH2F, {{200, -0.5, 200.}, CentAxis}}}); - QAregistry.add( - {"Tracks/Centrality/hFracAmbiguousMftTrks", - "; #it{N}_{ambiguous tracks} / #it{N}_{tracks}; centrality", - {HistType::kTH2F, {{100, 0., 1.}, CentAxis}}}); + {HistType::kTH2F, {{200, -0.5, 200.}, centAxis}}}); + qaregistry.add( + {"Tracks/Centrality/hFracAmbiguousMftTrks", + "; #it{N}_{ambiguous tracks} / #it{N}_{tracks}; centrality", + {HistType::kTH2F, {{100, 0., 1.}, centAxis}}}); } } /// Filters - tracks - Filter filtTrkEta = (aod::fwdtrack::eta < trkcuts.cfg_eta_max) && - (aod::fwdtrack::eta > trkcuts.cfg_eta_min); + Filter filtTrkEta = (aod::fwdtrack::eta < trkcuts.cfgEtaMax) && + (aod::fwdtrack::eta > trkcuts.cfgEtaMin); Filter filtATrackID = (aod::fwdtrack::bestCollisionId >= 0); - Filter filtATrackDCA = - (nabs(aod::fwdtrack::bestDCAXY) < trkcuts.cfg_max_dcaxy); + Filter filtATrackDCA = (nabs(aod::fwdtrack::bestDCAXY) < trkcuts.cfgDCAxyMax); /// Filters - mc particles Filter primaries = (aod::mcparticle::flags & @@ -520,7 +498,7 @@ struct PseudorapidityDensityMFT { /// Joined tables using FullBCs = soa::Join; using CollBCs = - soa::Join; + soa::Join; using Colls = soa::Join; using Coll = Colls::iterator; using CollsCent = soa::Join; @@ -531,55 +509,57 @@ struct PseudorapidityDensityMFT { using MFTTracksLabeled = soa::Join; /// Filtered tables - using filtMftTracks = soa::Filtered; - using filtMcMftTracks = soa::Filtered; - using filtBestTracks = soa::Filtered; - using filtParticles = soa::Filtered; - - template - bool isTrackSelected(const T& track) - { - if (track.eta() < trkcuts.cfg_eta_min || track.eta() > trkcuts.cfg_eta_max) + using FiltMftTracks = soa::Filtered; + using FiltMcMftTracks = soa::Filtered; + using FiltBestTracks = soa::Filtered; + using FiltParticles = soa::Filtered; + + template bool isTrackSelected(const T &track) { + if (track.eta() < trkcuts.cfgEtaMin || track.eta() > trkcuts.cfgEtaMax) return false; - if (trkcuts.cfg_require_ca && !track.isCA()) + if (trkcuts.cfgRequireCA && !track.isCA()) return false; - if (track.nClusters() < trkcuts.cfg_min_ncluster_mft) + if (track.nClusters() < trkcuts.cfgMinNclusterMft) return false; - if (track.pt() < trkcuts.cfg_min_pt) + if (track.pt() < trkcuts.cfgPtMin) return false; if (usePhiCut) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); - if (phi < 0.f || 2.f * M_PI < phi) { + if (phi < trkcuts.cfgPhiMin || trkcuts.cfgPhiMax < phi) { return false; } if ((phi < cfgPhiCut) || - ((phi > M_PI - cfgPhiCut) && (phi < M_PI + cfgPhiCut)) || - (phi > 2. * M_PI - cfgPhiCut) || - ((phi > ((M_PI / 2. - 0.1) * M_PI) - cfgPhiCut) && - (phi < ((M_PI / 2. - 0.1) * M_PI) + cfgPhiCut))) + ((phi > o2::constants::math::PI - cfgPhiCut) && + (phi < o2::constants::math::PI + cfgPhiCut)) || + (phi > o2::constants::math::TwoPI - cfgPhiCut) || + ((phi > + ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) - + cfgPhiCut) && + (phi < + ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) + + cfgPhiCut))) return false; } return true; } template - int countTracks(T const& tracks, float z, float c, float occ) - { + int countTracks(T const& tracks, float z, float c, float occ) { auto nTrk = 0; if (tracks.size() > 0) { - for (auto& track : tracks) { + for (auto const& track : tracks) { if (fillHis) { if constexpr (C::template contains()) { - QAregistry.fill(HIST("Tracks/Centrality/Chi2Eta"), track.chi2(), + qaregistry.fill(HIST("Tracks/Centrality/Chi2Eta"), track.chi2(), track.eta(), c); - QAregistry.fill(HIST("Tracks/Centrality/Chi2"), track.chi2(), c); - QAregistry.fill(HIST("Tracks/Centrality/NclustersEta"), + qaregistry.fill(HIST("Tracks/Centrality/Chi2"), track.chi2(), c); + qaregistry.fill(HIST("Tracks/Centrality/NclustersEta"), track.nClusters(), track.eta(), c); } else { - QAregistry.fill(HIST("Tracks/Chi2Eta"), track.chi2(), track.eta()); - QAregistry.fill(HIST("Tracks/Chi2"), track.chi2()); - QAregistry.fill(HIST("Tracks/NclustersEta"), track.nClusters(), + qaregistry.fill(HIST("Tracks/Chi2Eta"), track.chi2(), track.eta()); + qaregistry.fill(HIST("Tracks/Chi2"), track.chi2()); + qaregistry.fill(HIST("Tracks/NclustersEta"), track.nClusters(), track.eta()); } } @@ -589,14 +569,14 @@ struct PseudorapidityDensityMFT { if (fillHis) { float phi = track.phi(); o2::math_utils::bringTo02Pi(phi); - if (phi < 0.f || 2.f * M_PI < phi) { + if (phi < 0.f || o2::constants::math::TwoPI < phi) { continue; } if constexpr (C::template contains()) { registry.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c); registry.fill(HIST("Tracks/Centrality/PhiEta"), phi, track.eta(), c); - QAregistry.fill(HIST("Tracks/Centrality/Occupancy"), z, c, + qaregistry.fill(HIST("Tracks/Centrality/Occupancy"), z, c, track.eta(), track.phi(), occ); } else { registry.fill(HIST("Tracks/EtaZvtx"), track.eta(), z); @@ -610,12 +590,11 @@ struct PseudorapidityDensityMFT { } 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; if (besttracks.size() > 0) { - for (auto& atrack : besttracks) { + for (auto const& atrack : besttracks) { auto itrack = atrack.template mfttrack_as(); if (!isTrackSelected(itrack)) { continue; @@ -623,7 +602,7 @@ struct PseudorapidityDensityMFT { if (fillHis) { float phi = itrack.phi(); o2::math_utils::bringTo02Pi(phi); - if (phi < 0.f || 2.f * M_PI < phi) { + if (phi < 0.f || o2::constants::math::TwoPI < phi) { continue; } if constexpr (C::template contains()) { @@ -631,35 +610,35 @@ struct PseudorapidityDensityMFT { z, c); registry.fill(HIST("Tracks/Centrality/PhiEtaBest"), phi, itrack.eta(), c); - QAregistry.fill(HIST("Tracks/Centrality/OccupancyBest"), z, c, + qaregistry.fill(HIST("Tracks/Centrality/OccupancyBest"), z, c, itrack.eta(), itrack.phi(), occ); - QAregistry.fill(HIST("Tracks/Centrality/DCAXYPt"), itrack.pt(), + qaregistry.fill(HIST("Tracks/Centrality/DCAXYPt"), itrack.pt(), atrack.bestDCAXY(), c); - QAregistry.fill(HIST("Tracks/Centrality/DCAXY"), atrack.bestDCAXY(), + qaregistry.fill(HIST("Tracks/Centrality/DCAXY"), atrack.bestDCAXY(), c); - QAregistry.fill(HIST("Tracks/Centrality/NclustersEtaBest"), + qaregistry.fill(HIST("Tracks/Centrality/NclustersEtaBest"), itrack.nClusters(), itrack.eta(), c); if (itrack.collisionId() != atrack.bestCollisionId()) { - QAregistry.fill(HIST("Tracks/Centrality/ReTracksEtaZvtx"), + qaregistry.fill(HIST("Tracks/Centrality/ReTracksEtaZvtx"), itrack.eta(), z, c); - QAregistry.fill(HIST("Tracks/Centrality/ReTracksPhiEta"), phi, + qaregistry.fill(HIST("Tracks/Centrality/ReTracksPhiEta"), phi, itrack.eta(), c); } - QAregistry.fill(HIST("Tracks/Centrality/TrackAmbDegree"), + qaregistry.fill(HIST("Tracks/Centrality/TrackAmbDegree"), atrack.ambDegree(), c); } else { registry.fill(HIST("Tracks/EtaZvtxBest"), itrack.eta(), z); registry.fill(HIST("Tracks/PhiEtaBest"), phi, itrack.eta()); - QAregistry.fill(HIST("Tracks/DCAXYPt"), itrack.pt(), + qaregistry.fill(HIST("Tracks/DCAXYPt"), itrack.pt(), atrack.bestDCAXY()); - QAregistry.fill(HIST("Tracks/DCAXY"), atrack.bestDCAXY()); - QAregistry.fill(HIST("Tracks/NclustersEtaBest"), itrack.nClusters(), + qaregistry.fill(HIST("Tracks/DCAXY"), atrack.bestDCAXY()); + qaregistry.fill(HIST("Tracks/NclustersEtaBest"), itrack.nClusters(), itrack.eta()); if (itrack.collisionId() != atrack.bestCollisionId()) { - QAregistry.fill(HIST("Tracks/ReTracksEtaZvtx"), itrack.eta(), z); - QAregistry.fill(HIST("Tracks/ReTracksPhiEta"), phi, itrack.eta()); + qaregistry.fill(HIST("Tracks/ReTracksEtaZvtx"), itrack.eta(), z); + qaregistry.fill(HIST("Tracks/ReTracksPhiEta"), phi, itrack.eta()); } - QAregistry.fill(HIST("Tracks/TrackAmbDegree"), atrack.ambDegree()); + qaregistry.fill(HIST("Tracks/TrackAmbDegree"), atrack.ambDegree()); } } ++nATrk; @@ -668,11 +647,9 @@ struct PseudorapidityDensityMFT { return nATrk; } - template - int countPart(P const& particles) - { + template int countPart(P const& particles) { auto nCharged = 0; - for (auto& particle : particles) { + for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; } @@ -682,8 +659,7 @@ struct PseudorapidityDensityMFT { } template - bool isGoodEvent(C const& collision) - { + bool isGoodEvent(C const& collision) { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -744,8 +720,7 @@ struct PseudorapidityDensityMFT { /// @brief Selection of charged particles /// @return true: charged; false: not charged - bool isChrgParticle(int code) - { + bool isChrgParticle(int code) { auto p = pdg->GetParticle(code); auto charge = 0.; if (p != nullptr) { @@ -755,17 +730,16 @@ struct PseudorapidityDensityMFT { } template - void fillHist_MC(P const& particles, float cent, float zvtx, - bool const atLeastOne) - { - for (auto& particle : particles) { + void fillHistMC(P const& particles, float cent, float zvtx, + bool const atLeastOne) { + for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; } float phi = particle.phi(); o2::math_utils::bringTo02Pi(phi); - if (phi < 0.f || 2.f * M_PI < phi) { + if (phi < 0.f || o2::constants::math::TwoPI < phi) { continue; } if constexpr (isCent) { @@ -781,7 +755,7 @@ struct PseudorapidityDensityMFT { if (atLeastOne) { float phi = particle.phi(); o2::math_utils::bringTo02Pi(phi); - if (phi < 0.f || 2.f * M_PI < phi) { + if (phi < 0.f || o2::constants::math::TwoPI < phi) { continue; } if constexpr (isCent) { @@ -798,15 +772,14 @@ struct PseudorapidityDensityMFT { } /// @brief process fnc. for general event statistics - void processTagging(FullBCs const& bcs, CollsCent const& collisions) - { + void processTagging(FullBCs const& bcs, CollsCent const& collisions) { std::vector::iterator> cols; - for (auto& bc : bcs) { + for (auto const& bc : bcs) { if ((bc.selection_bit(aod::evsel::kIsBBT0A) && bc.selection_bit(aod::evsel::kIsBBT0C)) != 0) { registry.fill(HIST("hBcSel"), 0); cols.clear(); - for (auto& collision : collisions) { + for (auto const& collision : collisions) { if (collision.has_foundBC()) { if (collision.foundBCId() == bc.globalIndex()) { cols.emplace_back(collision); @@ -831,8 +804,7 @@ struct PseudorapidityDensityMFT { template void processData(typename C::iterator const& collision, - filtMftTracks const& tracks) - { + FiltMftTracks const& tracks) { float c = -1; if constexpr (C::template contains()) { c = collision.centFT0C(); @@ -847,14 +819,14 @@ struct PseudorapidityDensityMFT { auto occ = collision.trackOccupancyInTimeRange(); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/Selection"), 2., c); - QAregistry.fill(HIST("Events/Centrality/Occupancy"), z, c, occ); - QAregistry.fill(HIST("Events/Centrality/hcentFT0C"), c); + qaregistry.fill(HIST("Events/Centrality/Occupancy"), z, c, occ); + qaregistry.fill(HIST("Events/Centrality/hcentFT0C"), c); } else { registry.fill(HIST("Events/Selection"), 2.); } auto nTrk = countTracks( - tracks, z, c, occ); //!@note here we obtain eta-z and phi-eta + tracks, z, c, occ); //!@note here we obtain eta-z and phi-eta if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtx"), nTrk, z, c); } else { @@ -864,9 +836,8 @@ struct PseudorapidityDensityMFT { template void processDatawBestTracks( - typename C::iterator const& collision, filtMftTracks const& tracks, - soa::SmallGroups const& besttracks) - { + typename C::iterator const& collision, FiltMftTracks const& tracks, + soa::SmallGroups const& besttracks) { float c = -1; if constexpr (C::template contains()) { c = collision.centFT0C(); @@ -881,14 +852,14 @@ struct PseudorapidityDensityMFT { auto occ = collision.trackOccupancyInTimeRange(); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/Selection"), 2., c); - QAregistry.fill(HIST("Events/Centrality/OccupancyBest"), z, c, occ); + qaregistry.fill(HIST("Events/Centrality/OccupancyBest"), z, c, occ); } else { registry.fill(HIST("Events/Selection"), 2.); } auto nBestTrks = - countBestTracks(tracks, besttracks, z, c, - occ); //!@note here we obtain eta-z and phi-eta + countBestTracks(tracks, besttracks, z, c, + occ); //!@note here we obtain eta-z and phi-eta if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxBest"), nBestTrks, z, c); } else { @@ -898,8 +869,7 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on DATA and REC MC w/o centrality selection void processDataInclusive(Colls::iterator const& collision, - filtMftTracks const& tracks) - { + FiltMftTracks const& tracks) { processData(collision, tracks); } @@ -908,8 +878,7 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on DATA and REC MC w/ FT0C centrality selection void processDataCent(CollsCent::iterator const& collision, - filtMftTracks const& tracks) - { + FiltMftTracks const& tracks) { processData(collision, tracks); } @@ -919,9 +888,8 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on DATA and REC MC based on BestCollisionsFwd /// table w/o centrality selection void processDatawBestTracksInclusive( - Colls::iterator const& collision, filtMftTracks const& tracks, - soa::SmallGroups const& besttracks) - { + Colls::iterator const& collision, FiltMftTracks const& tracks, + soa::SmallGroups const& besttracks) { processDatawBestTracks(collision, tracks, besttracks); } @@ -931,9 +899,8 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on DATA and REC MC based on BestCollisionsFwd /// table w/ FT0C centrality selection void processDatawBestTracksCent( - CollsCent::iterator const& collision, filtMftTracks const& tracks, - soa::SmallGroups const& besttracks) - { + CollsCent::iterator const& collision, FiltMftTracks const& tracks, + soa::SmallGroups const& besttracks) { processDatawBestTracks(collision, tracks, besttracks); } @@ -941,26 +908,25 @@ struct PseudorapidityDensityMFT { "Count tracks in FT0C bins based on BestCollisionsFwd table", false); - Preslice perCol = o2::aod::fwdtrack::collisionId; - Partition mcSample = nabs(aod::mcparticle::eta) < 1.0f; + Preslice perCol = o2::aod::fwdtrack::collisionId; + Partition mcSample = nabs(aod::mcparticle::eta) < 1.0f; /// @brief process template function to run on MC truth /// @param cols subscribe to the collisions /// @param parts subscribe to filtered MC particle table template void processMC( - typename MC::iterator const& mcCollision, - soa::SmallGroups> const& collisions, - filtParticles const& particles, filtMcMftTracks const& tracks) - { - float c_gen = -1; + typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks) { + float cgen = -1; bool atLeastOne = false; int moreThanOne = 0; - for (auto& collision : collisions) { - float c_rec = -1; + for (auto const& collision : collisions) { + float crec = -1; if constexpr (C::template contains()) { - c_rec = collision.centFT0C(); - registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., c_rec); + crec = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., crec); } else { registry.fill(HIST("Events/EvtEffGen"), 1.); } @@ -968,7 +934,7 @@ struct PseudorapidityDensityMFT { if (isGoodEvent(collision)) { if constexpr (C::template contains()) { if (!atLeastOne) { - c_gen = c_rec; + cgen = crec; } } atLeastOne = true; @@ -976,24 +942,24 @@ struct PseudorapidityDensityMFT { auto z = collision.posZ(); if constexpr (C::template contains()) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., c_rec); - registry.fill(HIST("Events/Centrality/hRecCent"), c_rec); - registry.fill(HIST("Events/Centrality/hRecZvtxCent"), z, c_rec); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., crec); + registry.fill(HIST("Events/Centrality/hRecCent"), crec); + registry.fill(HIST("Events/Centrality/hRecZvtxCent"), z, crec); } else { registry.fill(HIST("Events/EvtEffGen"), 2.); } auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); + tracks.sliceBy(perCol, collision.globalIndex()); auto nTrkRec = - countTracks(perCollisionSample, z, c_rec, - collision.trackOccupancyInTimeRange()); + countTracks(perCollisionSample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { - QAregistry.fill(HIST("Events/Centrality/ZvtxDiff"), - collision.posZ() - mcCollision.posZ(), c_rec); + qaregistry.fill(HIST("Events/Centrality/ZvtxDiff"), + collision.posZ() - mcCollision.posZ(), crec); } else { - QAregistry.fill(HIST("Events/ZvtxDiff"), + qaregistry.fill(HIST("Events/ZvtxDiff"), collision.posZ() - mcCollision.posZ()); } @@ -1005,7 +971,7 @@ struct PseudorapidityDensityMFT { if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, - collision.posZ(), c_rec); + collision.posZ(), crec); } else { registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, collision.posZ()); } @@ -1013,19 +979,19 @@ struct PseudorapidityDensityMFT { } if constexpr (C::template contains()) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., c_gen); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., cgen); } else { registry.fill(HIST("Events/EvtEffGen"), 3.); } auto perCollMCsample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); - auto Nchrg = countPart(perCollMCsample); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + auto nchrg = countPart(perCollMCsample); if (moreThanOne > 1) { if constexpr (C::template contains()) { - QAregistry.fill(HIST("Events/Centrality/SplitMult"), Nchrg, c_gen); + qaregistry.fill(HIST("Events/Centrality/SplitMult"), nchrg, cgen); } else { - QAregistry.fill(HIST("Events/SplitMult"), Nchrg); + qaregistry.fill(HIST("Events/SplitMult"), nchrg); } } @@ -1033,30 +999,29 @@ struct PseudorapidityDensityMFT { auto nCharged = countPart(particles); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, zvtxMC, - c_gen); + cgen); } else { registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); } - fillHist_MC()>(particles, c_gen, + fillHistMC()>(particles, cgen, zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { - QAregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), - mcCollision.posZ(), c_gen); + qaregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), + mcCollision.posZ(), cgen); } else { - QAregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + qaregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); } } } /// @brief process fnc. to run on MC w/o centrality selection void processMCInclusive( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - filtParticles const& particles, filtMcMftTracks const& tracks) - { + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks) { processMC(mccollision, collisions, particles, tracks); } @@ -1066,10 +1031,9 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on MC w FT0C centrality selection void processMCCent( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - filtParticles const& particles, filtMcMftTracks const& tracks) - { + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks) { processMC(mccollision, collisions, particles, tracks); } @@ -1078,25 +1042,24 @@ struct PseudorapidityDensityMFT { "Count MC particles in FT0C bins", false); PresliceUnsorted perColU = - aod::fwdtrack::bestCollisionId; + aod::fwdtrack::bestCollisionId; /// @brief process template function to run on MC truth using /// aod::BestCollisionsFwd tracks template void processMCwBestTracks( - typename MC::iterator const& mcCollision, - soa::SmallGroups> const& collisions, - filtParticles const& particles, filtMcMftTracks const& tracks, - filtBestTracks const& besttracks) - { - float c_gen = -1; + typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks, + FiltBestTracks const& besttracks) { + float cgen = -1; bool atLeastOne = false; // int moreThanOne = 0; - for (auto& collision : collisions) { - float c_rec = -1; + for (auto const& collision : collisions) { + float crec = -1; if constexpr (C::template contains()) { - c_rec = collision.centFT0C(); - registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., c_rec); + crec = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., crec); } else { registry.fill(HIST("Events/EvtEffGen"), 1.); } @@ -1104,7 +1067,7 @@ struct PseudorapidityDensityMFT { if (isGoodEvent(collision)) { if constexpr (C::template contains()) { if (!atLeastOne) { - c_gen = c_rec; + cgen = crec; } } atLeastOne = true; @@ -1112,22 +1075,22 @@ struct PseudorapidityDensityMFT { auto z = collision.posZ(); if constexpr (C::template contains()) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., c_rec); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., crec); } else { registry.fill(HIST("Events/EvtEffGen"), 2.); } auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); + tracks.sliceBy(perCol, collision.globalIndex()); auto perCollisionASample = - besttracks.sliceBy(perColU, collision.globalIndex()); + besttracks.sliceBy(perColU, collision.globalIndex()); auto nTrkRec = countBestTracks( - perCollisionSample, perCollisionASample, z, c_rec, - collision.trackOccupancyInTimeRange()); + perCollisionSample, perCollisionASample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, - c_rec); + crec); } else { registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, z); } @@ -1135,7 +1098,7 @@ struct PseudorapidityDensityMFT { } if constexpr (C::template contains()) { - registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., c_gen); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., cgen); } else { registry.fill(HIST("Events/EvtEffGen"), 3.); } @@ -1144,20 +1107,20 @@ struct PseudorapidityDensityMFT { auto nCharged = countPart(particles); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, zvtxMC, - c_gen); + cgen); } else { registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); } - fillHist_MC()>(particles, c_gen, + fillHistMC()>(particles, cgen, zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { - QAregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), - mcCollision.posZ(), c_gen); + qaregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), + mcCollision.posZ(), cgen); } else { - QAregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + qaregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); } } } @@ -1165,15 +1128,14 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on MC (inclusive, using aod::BestCollisionsFwd /// tracks) void processMCwBestTracksInclusive( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - filtParticles const& particles, filtMcMftTracks const& tracks, - // aod::BestCollisionsFwd const - // &besttracks - filtBestTracks const& besttracks) - { + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks, + // aod::BestCollisionsFwd const + // &besttracks + FiltBestTracks const& besttracks) { processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); + mccollision, collisions, particles, tracks, besttracks); } PROCESS_SWITCH(PseudorapidityDensityMFT, processMCwBestTracksInclusive, @@ -1182,13 +1144,12 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on MC (FT0C centrality, using /// aod::BestCollisionsFwd tracks) void processMCwBestTracksCent( - aod::McCollisions::iterator const& mccollision, - soa::SmallGroups> const& collisions, - filtParticles const& particles, filtMcMftTracks const& tracks, - filtBestTracks const& besttracks) - { + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks, + FiltBestTracks const& besttracks) { processMCwBestTracks( - mccollision, collisions, particles, tracks, besttracks); + mccollision, collisions, particles, tracks, besttracks); } PROCESS_SWITCH(PseudorapidityDensityMFT, processMCwBestTracksCent, @@ -1197,19 +1158,18 @@ struct PseudorapidityDensityMFT { 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::flags & + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary); /// @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) - { - for (auto& collision : collisions) { + typename soa::Join const& collisions, + MC const& /*mccollisions*/, ParticlesI const& /*particles*/, + MFTTracksLabeled const& tracks) { + for (auto const& collision : collisions) { if (!isGoodEvent(collision)) { continue; } @@ -1217,27 +1177,27 @@ struct PseudorapidityDensityMFT { continue; } - float c_rec = -1; + float crec = -1; if constexpr (C::template contains()) { - c_rec = collision.centFT0C(); + crec = collision.centFT0C(); } auto mcCollision = collision.mcCollision(); auto particlesPerCol = primariesI->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); particlesPerCol.bindExternalIndices(&tracks); - for (auto& particle : particlesPerCol) { + for (auto const& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; } // MC gen if constexpr (C::template contains()) { - QAregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGen"), + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGen"), particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), c_rec); + mcCollision.posZ(), crec); } else { - QAregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffGen"), particle.pt(), + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ()); } // MC rec @@ -1245,57 +1205,57 @@ struct PseudorapidityDensityMFT { auto iscounted = false; auto ncnt = 0; auto relatedTracks = - particle.template mfttracks_as(); - for (auto& track : relatedTracks) { + particle.template mfttracks_as(); + for (auto const& track : relatedTracks) { if (!isTrackSelected(track)) { continue; } ++ncnt; if constexpr (C::template contains()) { if (!iscounted) { // primaries - QAregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffRec"), + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffRec"), particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), c_rec); + mcCollision.posZ(), crec); iscounted = true; } if (ncnt > 1) { // duplicates - QAregistry.fill(HIST("Tracks/Centrality/hPhiEtaDuplicates"), - track.phi(), track.eta(), c_rec); - QAregistry.fill( - HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), c_rec); + qaregistry.fill(HIST("Tracks/Centrality/hPhiEtaDuplicates"), + track.phi(), track.eta(), crec); + qaregistry.fill( + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); } } else { if (!iscounted) { // primaries - QAregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffRec"), + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffRec"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ()); iscounted = true; } if (ncnt > 1) { // duplicates - QAregistry.fill(HIST("Tracks/hPhiEtaDuplicates"), track.phi(), + qaregistry.fill(HIST("Tracks/hPhiEtaDuplicates"), track.phi(), track.eta()); - QAregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffDuplicates"), + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffDuplicates"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ()); } } } if constexpr (C::template contains()) { - QAregistry.fill(HIST("Tracks/Centrality/NmftTrkPerPart"), ncnt, - c_rec); + qaregistry.fill(HIST("Tracks/Centrality/NmftTrkPerPart"), ncnt, + crec); } else { - QAregistry.fill(HIST("Tracks/NmftTrkPerPart"), ncnt); + qaregistry.fill(HIST("Tracks/NmftTrkPerPart"), ncnt); } if (relatedTracks.size() > 1) { if constexpr (C::template contains()) { - QAregistry.fill( - HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), c_rec); + qaregistry.fill( + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); } else { - QAregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffGenDuplicates"), + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffGenDuplicates"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ()); } @@ -1308,10 +1268,9 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (inclusive, /// indexed) void processTrkEffIdxInlusive( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - MFTTracksLabeled const& tracks) - { + soa::Join const& collisions, + aod::McCollisions const& mccollisions, ParticlesI const& particles, + MFTTracksLabeled const& tracks) { processTrkEffIdx(collisions, mccollisions, particles, tracks); } @@ -1322,10 +1281,9 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (FT0 bins, /// indexed) void processTrkEffIdxCent( - soa::Join const& collisions, - aod::McCollisions const& mccollisions, ParticlesI const& particles, - MFTTracksLabeled const& tracks) - { + soa::Join const& collisions, + aod::McCollisions const& mccollisions, ParticlesI const& particles, + MFTTracksLabeled const& tracks) { processTrkEffIdx(collisions, mccollisions, particles, tracks); } @@ -1337,11 +1295,10 @@ struct PseudorapidityDensityMFT { /// on BestCollisionsFwd in FT0C bins template void processTrkEffBest( - typename soa::Join::iterator const& collision, - MC const& /*mccollisions*/, filtParticles const& particles, - filtMcMftTracks const& /*tracks*/, - soa::SmallGroups const& besttracks) - { + typename soa::Join::iterator const& collision, + MC const& /*mccollisions*/, FiltParticles const& particles, + FiltMcMftTracks const& /*tracks*/, + soa::SmallGroups const& besttracks) { if (!isGoodEvent(collision)) { return; } @@ -1349,49 +1306,49 @@ struct PseudorapidityDensityMFT { return; } - float c_rec = -1; + float crec = -1; if constexpr (C::template contains()) { - c_rec = collision.centFT0C(); + crec = collision.centFT0C(); } auto mcCollision = collision.mcCollision(); auto particlesPerCol = particles.sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); - for (auto& particle : particlesPerCol) { + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + for (auto const& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; } if constexpr (C::template contains()) { - QAregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestGen"), + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestGen"), particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), c_rec); + mcCollision.posZ(), crec); } else { - QAregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestGen"), particle.pt(), + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestGen"), particle.pt(), particle.phi(), particle.eta(), mcCollision.posZ()); } } for (auto const& track : besttracks) { - auto itrack = track.mfttrack_as(); + auto itrack = track.mfttrack_as(); if (!isTrackSelected(itrack)) { continue; } if (itrack.has_mcParticle()) { - auto particle = itrack.mcParticle_as(); + auto particle = itrack.mcParticle_as(); if constexpr (C::template contains()) { - QAregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestRec"), + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestRec"), particle.pt(), itrack.phi(), itrack.eta(), - mcCollision.posZ(), c_rec); + mcCollision.posZ(), crec); } else { - QAregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestRec"), particle.pt(), + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestRec"), particle.pt(), itrack.phi(), itrack.eta(), mcCollision.posZ()); } } else { if constexpr (C::template contains()) { - QAregistry.fill(HIST("Tracks/Centrality/hPtEffBestFakeRec"), - itrack.pt(), c_rec); + qaregistry.fill(HIST("Tracks/Centrality/hPtEffBestFakeRec"), + itrack.pt(), crec); } else { - QAregistry.fill(HIST("Tracks/hPtEffBestFakeRec"), itrack.pt()); + qaregistry.fill(HIST("Tracks/hPtEffBestFakeRec"), itrack.pt()); } } } @@ -1400,59 +1357,54 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (inclusive, based /// on BestCollisionsFwd) void processTrkEffBestInclusive( - soa::Join::iterator const& collision, - aod::McCollisions const& mccollisions, filtParticles const& particles, - filtMcMftTracks const& tracks, - soa::SmallGroups const& besttracks) - { + soa::Join::iterator const& collision, + aod::McCollisions const& mccollisions, FiltParticles const& particles, + FiltMcMftTracks const& tracks, + soa::SmallGroups const& besttracks) { processTrkEffBest(collision, mccollisions, particles, tracks, besttracks); } - PROCESS_SWITCH( - PseudorapidityDensityMFT, processTrkEffBestInclusive, - "Process tracking efficiency (inclusive, based on BestCollisionsFwd)", - false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processTrkEffBestInclusive, + "Process tracking efficiency (inclusive, based on BestCollisionsFwd)", + false); /// @brief process function to calculate tracking efficiency (in FT0 bins, /// based on BestCollisionsFwd) void processTrkEffBestCent( - soa::Join:: - iterator const& collision, - aod::McCollisions const& mccollisions, filtParticles const& particles, - filtMcMftTracks const& tracks, - soa::SmallGroups const& besttracks) - { + soa::Join::iterator const& collision, + aod::McCollisions const& mccollisions, FiltParticles const& particles, + FiltMcMftTracks const& tracks, + soa::SmallGroups const& besttracks) { processTrkEffBest( - collision, mccollisions, particles, tracks, besttracks); + collision, mccollisions, particles, tracks, besttracks); } - PROCESS_SWITCH( - PseudorapidityDensityMFT, processTrkEffBestCent, - "Process tracking efficiency (in FT0 bins, based on BestCollisionsFwd)", - false); + PROCESS_SWITCH(PseudorapidityDensityMFT, processTrkEffBestCent, + "Process tracking efficiency (in FT0 bins, based on BestCollisionsFwd)", + false); - Preslice filtTrkperCol = o2::aod::fwdtrack::collisionId; + Preslice filtTrkperCol = o2::aod::fwdtrack::collisionId; /// @brief process template function for MC QA checks template void processMcQA( - typename soa::SmallGroups> const& collisions, - aod::McCollisions const& mcCollisions, - filtParticles const& /*particles*/, MFTTracksLabeled const& tracks, - aod::AmbiguousMFTTracks const& atracks) - { + typename soa::SmallGroups> const + &collisions, + aod::McCollisions const& mcCollisions, + FiltParticles const& /*particles*/, MFTTracksLabeled const& tracks, + aod::AmbiguousMFTTracks const& atracks) { for (const auto& collision : collisions) { - float c_rec = -1; + float crec = -1; if constexpr (C::template contains()) { - c_rec = collision.centFT0C(); - QAregistry.fill( - HIST("Events/Centrality/hRecPerGenColls"), - static_cast(collisions.size()) / mcCollisions.size(), c_rec); + crec = collision.centFT0C(); + qaregistry.fill( + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), crec); } else { - QAregistry.fill(HIST("Events/hRecPerGenColls"), + qaregistry.fill(HIST("Events/hRecPerGenColls"), static_cast(collisions.size()) / - mcCollisions.size()); + mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1460,34 +1412,33 @@ struct PseudorapidityDensityMFT { } auto trkPerColl = tracks.sliceBy(filtTrkperCol, collision.globalIndex()); - uint Ntracks{0u}, Natracks{0u}; + uint ntracks{0u}, nAtracks{0u}; for (const auto& track : trkPerColl) { - Ntracks++; + ntracks++; for (const auto& atrack : atracks) { if (atrack.mfttrackId() == track.globalIndex()) { - Natracks++; + nAtracks++; break; } } } if constexpr (C::template contains()) { - QAregistry.fill(HIST("Tracks/Centrality/hNmftTrks"), Ntracks, c_rec); - QAregistry.fill(HIST("Tracks/Centrality/hFracAmbiguousMftTrks"), - static_cast(Natracks) / Ntracks, c_rec); + qaregistry.fill(HIST("Tracks/Centrality/hNmftTrks"), ntracks, crec); + qaregistry.fill(HIST("Tracks/Centrality/hFracAmbiguousMftTrks"), + static_cast(nAtracks) / ntracks, crec); } else { - QAregistry.fill(HIST("Tracks/hNmftTrks"), Ntracks); - QAregistry.fill(HIST("Tracks/hFracAmbiguousMftTrks"), - static_cast(Natracks) / Ntracks); + qaregistry.fill(HIST("Tracks/hNmftTrks"), ntracks); + qaregistry.fill(HIST("Tracks/hFracAmbiguousMftTrks"), + static_cast(nAtracks) / ntracks); } } } /// @brief process function for QA checks (inclusive) void processMcQAInclusive( - soa::SmallGroups> const& collisions, - aod::McCollisions const& mcCollisions, filtParticles const& particles, - MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) - { + soa::SmallGroups> const& collisions, + aod::McCollisions const& mcCollisions, FiltParticles const& particles, + MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) { processMcQA(collisions, mcCollisions, particles, tracks, atracks); } @@ -1496,10 +1447,9 @@ struct PseudorapidityDensityMFT { /// @brief process function for QA checks (in FT0 bins) void processMcQACent( - soa::SmallGroups> const& collisions, - aod::McCollisions const& mcCollisions, filtParticles const& particles, - MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) - { + soa::SmallGroups> const& collisions, + aod::McCollisions const& mcCollisions, FiltParticles const& particles, + MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) { processMcQA(collisions, mcCollisions, particles, tracks, atracks); } @@ -1508,7 +1458,6 @@ struct PseudorapidityDensityMFT { "Process MC QA checks (in FT0 bins)", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } diff --git a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx new file mode 100644 index 00000000000..8946e6683c4 --- /dev/null +++ b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx @@ -0,0 +1,1463 @@ +// Copyright 2020-2022 CERN and copyright holders of ALICE O2. +// See https://alice-o2.web.cern.ch/copyright for details of the copyright +// holders. All rights not expressly granted are reserved. +// +// This software is distributed under the terms of the GNU General Public +// License v3 (GPL Version 3), copied verbatim in the file "COPYING". +// +// In applying this license CERN does not waive the privileges and immunities +// granted to it by virtue of its status as an Intergovernmental Organization +// or submit itself to any jurisdiction. +/// +/// \brief Task for calculating dNdeta in Pb-Pb collisions using MFT detector +/// \author Gyula Bencedi, gyula.bencedi@cern.ch +/// \since Nov 2024 + +#include +#include +#include + +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisDataModel.h" +#include "Framework/AnalysisTask.h" +#include "Framework/Configurable.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/RuntimeError.h" +#include "Framework/runDataProcessing.h" + +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/CollisionAssociationTables.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/TrackSelectionTables.h" +#include "CommonConstants/MathConstants.h" + +#include "MathUtils/Utils.h" +#include "ReconstructionDataFormats/GlobalTrackID.h" + +#include + +#include "Index.h" +#include "bestCollisionTable.h" + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod::track; +using namespace o2::aod::fwdtrack; + +AxisSpec ptAxis = {1001, -0.005, 10.005}; +AxisSpec multAxis = {701, -0.5, 700.5, "N_{trk}"}; +AxisSpec zAxis = {60, -30., 30.}; +AxisSpec deltaZAxis = {61, -6.1, 6.1}; +AxisSpec dcaxyAxis = {500, -1, 50}; +AxisSpec phiAxis = {629, 0, o2::constants::math::TwoPI, "Rad", "#phi"}; +AxisSpec etaAxis = {20, -4., -2.}; + +struct DndetaMFTPbPb { + SliceCache cache; + + // Histogram registry + HistogramRegistry registry{ + "registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + HistogramRegistry qaregistry{ + "qaregistry", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; + + // analysis specific conf. + Configurable usePhiCut{"usePhiCut", false, "use azimuthal angle cut"}; + Configurable cfgPhiCut{"cfgPhiCut", 0.1f, + "Cut on azimuthal angle of MFT tracks"}; + + // track selection conf. + struct : ConfigurableGroup { + Configurable cfgPhiMin{"cfgPhiMin", 0.f, ""}; + Configurable cfgPhiMax{"cfgPhiMax", 6.2832, ""}; + Configurable cfgEtaMin{"cfgEtaMin", -3.6f, ""}; + Configurable cfgEtaMax{"cfgEtaMax", -2.5f, ""}; + Configurable cfgMinNclusterMft{"cfgMinNclusterMft", 5, + "minimum number of MFT clusters"}; + Configurable cfgPtMin{"cfgPtMin", 0., + "minimum pT of the MFT tracks"}; + Configurable cfgRequireCA{"cfgRequireCA", false, + "Use Cellular Automaton track-finding algorithm"}; + Configurable cfgDCAxyMax{"cfgDCAxyMax", 2.0f, "Cut on dcaXY"}; + } trkcuts; + + // event selection conf. + Configurable cfgCutZvtx{"cfgCutZvtx", 10.0f, "Cut on z-vtx"}; + Configurable cfgCutCent{"cfgCutCent", 80.0f, + "Cut on maximum centrality"}; + Configurable useZDiffCut{"useZDiffCut", false, + "use Zvtx reco-mc diff. cut"}; + Configurable maxZvtxDiff{"maxZvtxDiff", 1.0f, + "max allowed Z vtx difference for reconstruced collisions (cm)"}; + Configurable requireNoCollInTimeRangeStd{"requireNoCollInTimeRangeStd", false, + "reject collisions corrupted by the cannibalism, with other collisions " + "within +/- 10 microseconds"}; + Configurable requireNoCollInTimeRangeNarrow{"requireNoCollInTimeRangeNarrow", false, + "reject collisions corrupted by the cannibalism, with other collisions " + "within +/- 10 microseconds"}; + ConfigurableAxis occupancyBins{"occupancyBins", + {VARIABLE_WIDTH, 0.0f, 250.0f, 500.0f, 750.0f, + 1000.0f, 1500.0f, 2000.0f, 3000.0f, 4500.0f, + 6000.0f, 8000.0f, 10000.0f, 50000.0f}, + "Occupancy"}; + Configurable minOccupancy{"minOccupancy", -1, "minimum occupancy from neighbouring collisions"}; + Configurable maxOccupancy{"maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; + ConfigurableAxis centBins{"centBins", + {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, + ""}; + + Service pdg; + + /// @brief init function, definition of histograms + void init(InitContext &) { + if (static_cast(doprocessDataInclusive) + + static_cast(doprocessDatawBestTracksInclusive) > + 1) { + LOGP(fatal, "Either processDataInclusive OR " + "processDatawBestTracksInclusive should be enabled!"); + } + if (static_cast(doprocessDataCent) + + static_cast(doprocessDatawBestTracksCent) > + 1) { + LOGP(fatal, "Either processDataCent OR processDatawBestTracksCent should " + "be enabled!"); + } + if (static_cast(doprocessMCInclusive) + + static_cast(doprocessMCwBestTracksInclusive) > + 1) { + LOGP(fatal, "Either processMCInclusive OR processMCwBestTracksInclusive " + "should be enabled!"); + } + if (static_cast(doprocessMCCent) + + static_cast(doprocessMCwBestTracksCent) > + 1) { + LOGP(fatal, "Either processMCCent OR processMCwBestTracksCent should be " + "enabled!"); + } + + auto hev = registry.add("hEvtSel", "hEvtSel", HistType::kTH1F, + {{10, -0.5f, +9.5f}}); + hev->GetXaxis()->SetBinLabel(1, "All collisions"); + hev->GetXaxis()->SetBinLabel(2, "Ev. sel."); + hev->GetXaxis()->SetBinLabel(3, "kIsGoodZvtxFT0vsPV"); + hev->GetXaxis()->SetBinLabel(4, "NoSameBunchPileup"); + hev->GetXaxis()->SetBinLabel(5, "Z-vtx cut"); + hev->GetXaxis()->SetBinLabel(6, "kNoCollInTimeRangeStd"); + hev->GetXaxis()->SetBinLabel(7, "kNoCollInTimeRangeNarrow"); + hev->GetXaxis()->SetBinLabel(8, "Below min occup."); + hev->GetXaxis()->SetBinLabel(9, "Above max occup."); + + 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"); + + AxisSpec centAxis = {centBins, "Centrality", "CentralityAxis"}; + AxisSpec occupancyAxis = {occupancyBins, "Occupancy", "occupancyAxis"}; + + if (doprocessDataInclusive || doprocessDatawBestTracksInclusive) { + registry.add({"Events/Selection", + ";status;events", + {HistType::kTH1F, {{2, 0.5, 2.5}}}}); + auto hstat = registry.get(HIST("Events/Selection")); + auto *x = hstat->GetXaxis(); + x->SetBinLabel(1, "All"); + x->SetBinLabel(2, "Selected"); + + registry.add({"Events/NtrkZvtx", + "; N_{trk}; Z_{vtx} (cm);", + {HistType::kTH2F, {multAxis, zAxis}}}); + registry.add({"Tracks/EtaZvtx", + "; #eta; Z_{vtx} (cm);", + {HistType::kTH2F, {etaAxis, zAxis}}}); + registry.add({"Tracks/PhiEta", + "; #varphi; #eta;", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add({"Tracks/Chi2Eta", + "; #chi^{2}; #it{#eta};", + {HistType::kTH2F, {{600, 0, 20}, {100, -8, 8}}}}); + qaregistry.add( + {"Tracks/Chi2", "; #chi^{2};", {HistType::kTH1F, {{600, 0, 20}}}}); + qaregistry.add({"Tracks/NclustersEta", + "; nClusters; #eta;", + {HistType::kTH2F, {{7, 4, 10}, {100, -8, 8}}}}); + qaregistry.add("Events/Occupancy", "; Z_{vtx} (cm); Occupancy", + HistType::kTH2F, {zAxis, occupancyAxis}, false); + + if (doprocessDatawBestTracksInclusive) { + registry.add({"Events/NtrkZvtxBest", + "; N_{trk}; Z_{vtx} (cm);", + {HistType::kTH2F, {multAxis, zAxis}}}); + registry.add({"Tracks/EtaZvtxBest", + "; #eta; Z_{vtx} (cm);", + {HistType::kTH2F, {etaAxis, zAxis}}}); + registry.add({"Tracks/PhiEtaBest", + "; #varphi; #eta;", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add({"Tracks/NclustersEtaBest", + "; nClusters; #eta;", + {HistType::kTH2F, {{7, 4, 10}, {100, -8, 8}}}}); + qaregistry.add({"Tracks/DCAXYPt", + " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", + {HistType::kTH2F, {ptAxis, dcaxyAxis}}}); + qaregistry.add({"Tracks/DCAXY", + " ; DCA_{XY} (cm)", + {HistType::kTH1F, {dcaxyAxis}}}); + qaregistry.add({"Tracks/ReTracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH2F, {etaAxis, zAxis}}}); + qaregistry.add({"Tracks/ReTracksPhiEta", + "; #varphi; #eta; tracks", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add({"Tracks/TrackAmbDegree", + " ; N_{coll}^{comp}", + {HistType::kTH1F, {{51, -0.5, 50.5}}}}); + } + } + + if (doprocessDataCent || doprocessDatawBestTracksCent) { + registry.add({"Events/Centrality/Selection", + ";status;centrality;events", + {HistType::kTH2F, {{2, 0.5, 2.5}, centAxis}}}); + auto hstat = registry.get(HIST("Events/Centrality/Selection")); + auto *x = hstat->GetXaxis(); + x->SetBinLabel(1, "All"); + x->SetBinLabel(2, "Selected"); + + registry.add({"Events/Centrality/NtrkZvtx", + "; N_{trk}; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtx", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); + registry.add({"Tracks/Centrality/PhiEta", + "; #varphi; #eta; centrality", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/hcentFT0C", + " ; cent FT0C", + {HistType::kTH1F, {centAxis}}, + true}); + qaregistry.add( + {"Tracks/Centrality/Chi2Eta", + "; #chi^{2}; #it{#eta}; centrality", + {HistType::kTH3F, {{600, 0, 20}, {100, -8, 8}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/Chi2", + "; #chi^{2}; centrality", + {HistType::kTH2F, {{600, 0, 20}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/NclustersEta", + "; nClusters; #eta; centrality", + {HistType::kTH3F, {{7, 4, 10}, {100, -8, 8}, centAxis}}}); + qaregistry.add("Events/Centrality/Occupancy", + "; Z_{vtx} (cm); centrality; Occupancy", HistType::kTH3F, + {zAxis, centAxis, occupancyAxis}, false); + qaregistry.add("Tracks/Centrality/Occupancy", "dndeta occupancy", + HistType::kTHnSparseF, + {zAxis, centAxis, etaAxis, phiAxis, occupancyAxis}, false); + + if (doprocessDatawBestTracksCent) { + registry.add({"Events/Centrality/NtrkZvtxBest", + "; N_{trk}; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxBest", + "; #eta; Z_{vtx} (cm); centrality", + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); + registry.add({"Tracks/Centrality/PhiEtaBest", + "; #varphi; #eta; centrality", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add( + {"Tracks/Centrality/NclustersEtaBest", + "; nClusters; #eta; centrality", + {HistType::kTH3F, {{7, 4, 10}, {100, -8, 8}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/TrackAmbDegree", + " ; N_{coll}^{comp}", + {HistType::kTH2F, {{51, -0.5, 50.5}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/DCAXY", + " ; DCA_{XY} (cm)", + {HistType::kTH2F, {dcaxyAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/DCAXYPt", + " ; p_{T} (GeV/c) ; DCA_{XY} (cm); centrality", + {HistType::kTH3F, {ptAxis, dcaxyAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/ReTracksEtaZvtx", + "; #eta; #it{z}_{vtx} (cm); tracks", + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/ReTracksPhiEta", + "; #varphi; #eta; tracks", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add("Events/Centrality/OccupancyBest", + "; Z_{vtx} (cm); centrality; Occupancy", HistType::kTH3F, + {zAxis, centAxis, occupancyAxis}, false); + qaregistry.add("Tracks/Centrality/OccupancyBest", "dndeta occupancy", + HistType::kTHnSparseF, + {zAxis, centAxis, etaAxis, phiAxis, occupancyAxis}, + false); + } + } + + if (doprocessMCInclusive || doprocessMCwBestTracksInclusive) { + registry.add({"Events/EvtEffGen", + ";status;events", + {HistType::kTH1F, {{3, 0.5, 3.5}}}}); + auto heff = registry.get(HIST("Events/EvtEffGen")); + auto *x = heff->GetXaxis(); + x->SetBinLabel(1, "All reconstructed"); + x->SetBinLabel(2, "Selected reconstructed"); + x->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);", + {HistType::kTH2F, {multAxis, zAxis}}}); + registry.add({"Tracks/EtaZvtxGen", + "; #eta; Z_{vtx} (cm);", + {HistType::kTH2F, {etaAxis, zAxis}}}); + registry.add({"Tracks/PhiEtaGen", + "; #varphi; #eta;", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + 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}", {HistType::kTH1F, {multAxis}}}); + } + + if (doprocessMCCent || doprocessMCwBestTracksCent) { + registry.add({"Events/Centrality/EvtEffGen", + ";status;events", + {HistType::kTH2F, {{3, 0.5, 3.5}, centAxis}}}); + auto heff = registry.get(HIST("Events/Centrality/EvtEffGen")); + auto *x = heff->GetXaxis(); + x->SetBinLabel(1, "All reconstructed"); + x->SetBinLabel(2, "Selected reconstructed"); + x->SetBinLabel(3, "All generated"); + + registry.add({"Events/Centrality/NtrkZvtxGen_t", + "; N_{trk}; Z_{vtx} (cm);", + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); + registry.add({"Events/Centrality/NtrkZvtxGen", + "; N_{trk}; Z_{vtx} (cm);", + {HistType::kTH3F, {multAxis, zAxis, centAxis}}}); + registry.add({"Events/Centrality/hRecCent", + "Events/Centrality/hRecCent", + {HistType::kTH1F, {centAxis}}}); + registry.add({"Events/Centrality/hRecZvtxCent", + "Events/Centrality/hRecZvtxCent", + {HistType::kTH2F, {zAxis, centAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxGen", + "; #eta; Z_{vtx} (cm);", + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); + registry.add({"Tracks/Centrality/PhiEtaGen", + "; #varphi; #eta;", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + registry.add({"Tracks/Centrality/EtaZvtxGen_t", + "; #eta; Z_{vtx} (cm);", + {HistType::kTH3F, {etaAxis, zAxis, centAxis}}}); + registry.add({"Tracks/Centrality/PhiEtaGen_t", + "; #varphi; #eta;", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/NotFoundEventZvtx", + " ; #it{z}_{vtx} (cm)", + {HistType::kTH2F, {zAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/ZvtxDiff", + " ; Z_{rec} - Z_{gen} (cm)", + {HistType::kTH2F, {deltaZAxis, centAxis}}}); + qaregistry.add({"Events/Centrality/SplitMult", + " ; N_{gen}", + {HistType::kTH2F, {multAxis, centAxis}}}); + } + + if (doprocessTrkEffIdxInlusive) { + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffRec", + "hPtPhiEtaZvtxEffRec", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add({"Tracks/hPhiEtaDuplicates", + " ; p_{T} (GeV/c);", + {HistType::kTH2F, {phiAxis, etaAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffDuplicates", + "hPtPhiEtaZvtxEffDuplicates", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffGenDuplicates", + "hPtPhiEtaZvtxEffGenDuplicates", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add({"Tracks/NmftTrkPerPart", + "; #it{N}_{mft tracks per particle};", + {HistType::kTH1F, {{200, -0.5, 200.}}}}); + } + + if (doprocessTrkEffIdxCent) { + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffRec", + "hPtPhiEtaZvtxEffRec", + {HistType::kTHnSparseF, + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPhiEtaDuplicates", + " ; p_{T} (GeV/c);", + {HistType::kTH3F, {phiAxis, etaAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates", + "hPtPhiEtaZvtxEffDuplicates", + {HistType::kTHnSparseF, + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates", + "hPtPhiEtaZvtxEffGenDuplicates", + {HistType::kTHnSparseF, + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/NmftTrkPerPart", + "; #it{N}_{mft tracks per particle};", + {HistType::kTH2F, {{200, -0.5, 200.}, centAxis}}}); + } + + if (doprocessTrkEffBestInclusive) { + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffBestGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add( + {"Tracks/hPtPhiEtaZvtxEffBestRec", + "hPtPhiEtaZvtxEffRec", + {HistType::kTHnSparseF, {ptAxis, phiAxis, etaAxis, zAxis}}}); + qaregistry.add({"Tracks/hPtEffBestFakeRec", + " ; p_{T} (GeV/c);", + {HistType::kTH1F, {ptAxis}}}); + } + + if (doprocessTrkEffBestCent) { + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffBestGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtPhiEtaZvtxEffBestRec", + "hPtPhiEtaZvtxEffRec", + {HistType::kTHnSparseF, + {ptAxis, phiAxis, etaAxis, zAxis, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hPtEffBestFakeRec", + " ; p_{T} (GeV/c);", + {HistType::kTH2F, {ptAxis, centAxis}}}); + } + + if (doprocessMcQAInclusive) { + qaregistry.add({"Events/hRecPerGenColls", + "; #it{N}_{reco collisions} / #it{N}_{gen collisions};", + {HistType::kTH1F, {{200, 0., 2.}}}}); + qaregistry.add({"Tracks/hNmftTrks", + "; #it{N}_{mft tracks};", + {HistType::kTH1F, {{200, -0.5, 200.}}}}); + qaregistry.add({"Tracks/hFracAmbiguousMftTrks", + "; #it{N}_{ambiguous tracks} / #it{N}_{tracks};", + {HistType::kTH1F, {{100, 0., 1.}}}}); + } + + if (doprocessMcQACent) { + qaregistry.add( + {"Events/Centrality/hRecPerGenColls", + "; #it{N}_{reco collisions} / #it{N}_{gen collisions}; centrality", + {HistType::kTH2F, {{200, 0., 2.}, centAxis}}}); + qaregistry.add({"Tracks/Centrality/hNmftTrks", + "; #it{N}_{mft tracks}; centrality", + {HistType::kTH2F, {{200, -0.5, 200.}, centAxis}}}); + qaregistry.add( + {"Tracks/Centrality/hFracAmbiguousMftTrks", + "; #it{N}_{ambiguous tracks} / #it{N}_{tracks}; centrality", + {HistType::kTH2F, {{100, 0., 1.}, centAxis}}}); + } + } + + /// Filters - tracks + Filter filtTrkEta = (aod::fwdtrack::eta < trkcuts.cfgEtaMax) && + (aod::fwdtrack::eta > trkcuts.cfgEtaMin); + Filter filtATrackID = (aod::fwdtrack::bestCollisionId >= 0); + Filter filtATrackDCA = (nabs(aod::fwdtrack::bestDCAXY) < trkcuts.cfgDCAxyMax); + + /// Filters - mc particles + Filter primaries = (aod::mcparticle::flags & + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary; + + /// Joined tables + using FullBCs = soa::Join; + using CollBCs = + soa::Join; + using Colls = soa::Join; + using Coll = Colls::iterator; + using CollsCent = soa::Join; + using CollCent = CollsCent::iterator; + using CollsGenCent = soa::Join; + using CollGenCent = CollsGenCent::iterator; + using MFTTracksLabeled = soa::Join; + + /// Filtered tables + using FiltMftTracks = soa::Filtered; + using FiltMcMftTracks = soa::Filtered; + using FiltBestTracks = soa::Filtered; + using FiltParticles = soa::Filtered; + + template bool isTrackSelected(const T &track) { + if (track.eta() < trkcuts.cfgEtaMin || track.eta() > trkcuts.cfgEtaMax) + return false; + if (trkcuts.cfgRequireCA && !track.isCA()) + return false; + if (track.nClusters() < trkcuts.cfgMinNclusterMft) + return false; + if (track.pt() < trkcuts.cfgPtMin) + return false; + if (usePhiCut) { + float phi = track.phi(); + o2::math_utils::bringTo02Pi(phi); + if (phi < trkcuts.cfgPhiMin || trkcuts.cfgPhiMax < phi) { + return false; + } + if ((phi < cfgPhiCut) || + ((phi > o2::constants::math::PI - cfgPhiCut) && + (phi < o2::constants::math::PI + cfgPhiCut)) || + (phi > o2::constants::math::TwoPI - cfgPhiCut) || + ((phi > + ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) - + cfgPhiCut) && + (phi < + ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) + + cfgPhiCut))) + return false; + } + return true; + } + + template + int countTracks(T const& tracks, float z, float c, float occ) { + auto nTrk = 0; + if (tracks.size() > 0) { + for (auto const& track : tracks) { + if (fillHis) { + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Tracks/Centrality/Chi2Eta"), track.chi2(), + track.eta(), c); + qaregistry.fill(HIST("Tracks/Centrality/Chi2"), track.chi2(), c); + qaregistry.fill(HIST("Tracks/Centrality/NclustersEta"), + track.nClusters(), track.eta(), c); + } else { + qaregistry.fill(HIST("Tracks/Chi2Eta"), track.chi2(), track.eta()); + qaregistry.fill(HIST("Tracks/Chi2"), track.chi2()); + qaregistry.fill(HIST("Tracks/NclustersEta"), track.nClusters(), + track.eta()); + } + } + if (!isTrackSelected(track)) { + continue; + } + if (fillHis) { + float phi = track.phi(); + o2::math_utils::bringTo02Pi(phi); + if (phi < 0.f || o2::constants::math::TwoPI < phi) { + continue; + } + if constexpr (C::template contains()) { + registry.fill(HIST("Tracks/Centrality/EtaZvtx"), track.eta(), z, c); + registry.fill(HIST("Tracks/Centrality/PhiEta"), phi, track.eta(), + c); + qaregistry.fill(HIST("Tracks/Centrality/Occupancy"), z, c, + track.eta(), track.phi(), occ); + } else { + registry.fill(HIST("Tracks/EtaZvtx"), track.eta(), z); + registry.fill(HIST("Tracks/PhiEta"), phi, track.eta()); + } + } + ++nTrk; + } + } + return nTrk; + } + + template + int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, + float c, float occ) { + auto nATrk = 0; + if (besttracks.size() > 0) { + for (auto const& atrack : besttracks) { + auto itrack = atrack.template mfttrack_as(); + if (!isTrackSelected(itrack)) { + continue; + } + if (fillHis) { + float phi = itrack.phi(); + o2::math_utils::bringTo02Pi(phi); + if (phi < 0.f || o2::constants::math::TwoPI < phi) { + continue; + } + if constexpr (C::template contains()) { + registry.fill(HIST("Tracks/Centrality/EtaZvtxBest"), itrack.eta(), + z, c); + registry.fill(HIST("Tracks/Centrality/PhiEtaBest"), phi, + itrack.eta(), c); + qaregistry.fill(HIST("Tracks/Centrality/OccupancyBest"), z, c, + itrack.eta(), itrack.phi(), occ); + qaregistry.fill(HIST("Tracks/Centrality/DCAXYPt"), itrack.pt(), + atrack.bestDCAXY(), c); + qaregistry.fill(HIST("Tracks/Centrality/DCAXY"), atrack.bestDCAXY(), + c); + qaregistry.fill(HIST("Tracks/Centrality/NclustersEtaBest"), + itrack.nClusters(), itrack.eta(), c); + if (itrack.collisionId() != atrack.bestCollisionId()) { + qaregistry.fill(HIST("Tracks/Centrality/ReTracksEtaZvtx"), + itrack.eta(), z, c); + qaregistry.fill(HIST("Tracks/Centrality/ReTracksPhiEta"), phi, + itrack.eta(), c); + } + qaregistry.fill(HIST("Tracks/Centrality/TrackAmbDegree"), + atrack.ambDegree(), c); + } else { + registry.fill(HIST("Tracks/EtaZvtxBest"), itrack.eta(), z); + registry.fill(HIST("Tracks/PhiEtaBest"), phi, itrack.eta()); + qaregistry.fill(HIST("Tracks/DCAXYPt"), itrack.pt(), + atrack.bestDCAXY()); + qaregistry.fill(HIST("Tracks/DCAXY"), atrack.bestDCAXY()); + qaregistry.fill(HIST("Tracks/NclustersEtaBest"), itrack.nClusters(), + itrack.eta()); + if (itrack.collisionId() != atrack.bestCollisionId()) { + qaregistry.fill(HIST("Tracks/ReTracksEtaZvtx"), itrack.eta(), z); + qaregistry.fill(HIST("Tracks/ReTracksPhiEta"), phi, itrack.eta()); + } + qaregistry.fill(HIST("Tracks/TrackAmbDegree"), atrack.ambDegree()); + } + } + ++nATrk; + } + } + return nATrk; + } + + template int countPart(P const& particles) { + auto nCharged = 0; + for (auto const& particle : particles) { + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + nCharged++; + } + return nCharged; + } + + template + bool isGoodEvent(C const& collision) { + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 0); + } + if (!collision.sel8()) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 1); + } + if (!collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV)) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 2); + } + if (!collision.selection_bit(aod::evsel::kNoSameBunchPileup)) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 3); + } + if (std::abs(collision.posZ()) >= cfgCutZvtx) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 4); + } + if (requireNoCollInTimeRangeStd && + !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 5); + } + if (requireNoCollInTimeRangeNarrow && + !collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeNarrow)) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 6); + } + if (minOccupancy > 0 && + collision.trackOccupancyInTimeRange() < minOccupancy) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 7); + } + if (maxOccupancy > 0 && + collision.trackOccupancyInTimeRange() > maxOccupancy) { + return false; + } + if constexpr (fillHis) { + registry.fill(HIST("hEvtSel"), 8); + } + return true; + } + + /// @brief Selection of charged particles + /// @return true: charged; false: not charged + bool isChrgParticle(int code) { + auto p = pdg->GetParticle(code); + auto charge = 0.; + if (p != nullptr) { + charge = p->Charge(); + } + return std::abs(charge) >= 3.; + } + + template + void fillHistMC(P const& particles, float cent, float zvtx, + bool const atLeastOne) { + for (auto const& particle : particles) { + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + + float phi = particle.phi(); + o2::math_utils::bringTo02Pi(phi); + if (phi < 0.f || o2::constants::math::TwoPI < phi) { + continue; + } + if constexpr (isCent) { + registry.fill(HIST("Tracks/Centrality/EtaZvtxGen_t"), particle.eta(), + zvtx, cent); + registry.fill(HIST("Tracks/Centrality/PhiEtaGen_t"), phi, + particle.eta(), cent); + } else { + registry.fill(HIST("Tracks/EtaZvtxGen_t"), particle.eta(), zvtx); + registry.fill(HIST("Tracks/PhiEtaGen_t"), phi, particle.eta()); + } + + if (atLeastOne) { + float phi = particle.phi(); + o2::math_utils::bringTo02Pi(phi); + if (phi < 0.f || o2::constants::math::TwoPI < phi) { + continue; + } + if constexpr (isCent) { + registry.fill(HIST("Tracks/Centrality/EtaZvtxGen"), particle.eta(), + zvtx, cent); + registry.fill(HIST("Tracks/Centrality/PhiEtaGen"), phi, + particle.eta(), cent); + } else { + registry.fill(HIST("Tracks/EtaZvtxGen"), particle.eta(), zvtx); + registry.fill(HIST("Tracks/PhiEtaGen"), phi, particle.eta()); + } + } + } + } + + /// @brief process fnc. for general event statistics + void processTagging(FullBCs const& bcs, CollsCent const& collisions) { + std::vector::iterator> cols; + for (auto const& bc : bcs) { + if ((bc.selection_bit(aod::evsel::kIsBBT0A) && + bc.selection_bit(aod::evsel::kIsBBT0C)) != 0) { + registry.fill(HIST("hBcSel"), 0); + cols.clear(); + for (auto const& collision : collisions) { + if (collision.has_foundBC()) { + if (collision.foundBCId() == bc.globalIndex()) { + cols.emplace_back(collision); + } + } else if (collision.bcId() == bc.globalIndex()) { + cols.emplace_back(collision); + } + } + LOGP(debug, "BC {} has {} collisions", bc.globalBC(), cols.size()); + if (!cols.empty()) { + registry.fill(HIST("hBcSel"), 1); + if (cols.size() > 1) { + registry.fill(HIST("hBcSel"), 2); + } + } + } + } + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processTagging, + "Collect event sample stats", true); + + template + void processData(typename C::iterator const& collision, + FiltMftTracks const& tracks) { + float c = -1; + if constexpr (C::template contains()) { + c = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/Selection"), 1., c); + } else { + registry.fill(HIST("Events/Selection"), 1.); + } + if (!isGoodEvent(collision)) { + return; + } + auto z = collision.posZ(); + auto occ = collision.trackOccupancyInTimeRange(); + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/Selection"), 2., c); + qaregistry.fill(HIST("Events/Centrality/Occupancy"), z, c, occ); + qaregistry.fill(HIST("Events/Centrality/hcentFT0C"), c); + } else { + registry.fill(HIST("Events/Selection"), 2.); + } + + auto nTrk = countTracks( + tracks, z, c, occ); //!@note here we obtain eta-z and phi-eta + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/NtrkZvtx"), nTrk, z, c); + } else { + registry.fill(HIST("Events/NtrkZvtx"), nTrk, z); + } + } + + template + void processDatawBestTracks( + typename C::iterator const& collision, FiltMftTracks const& tracks, + soa::SmallGroups const& besttracks) { + float c = -1; + if constexpr (C::template contains()) { + c = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/Selection"), 1., c); + } else { + registry.fill(HIST("Events/Selection"), 1.); + } + if (!isGoodEvent(collision)) { + return; + } + auto z = collision.posZ(); + auto occ = collision.trackOccupancyInTimeRange(); + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/Selection"), 2., c); + qaregistry.fill(HIST("Events/Centrality/OccupancyBest"), z, c, occ); + } else { + registry.fill(HIST("Events/Selection"), 2.); + } + + auto nBestTrks = + countBestTracks(tracks, besttracks, z, c, + occ); //!@note here we obtain eta-z and phi-eta + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/NtrkZvtxBest"), nBestTrks, z, c); + } else { + registry.fill(HIST("Events/NtrkZvtxBest"), nBestTrks, z); + } + } + + /// @brief process fnc. to run on DATA and REC MC w/o centrality selection + void processDataInclusive(Colls::iterator const& collision, + FiltMftTracks const& tracks) { + processData(collision, tracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processDataInclusive, "Count tracks", + false); + + /// @brief process fnc. to run on DATA and REC MC w/ FT0C centrality selection + void processDataCent(CollsCent::iterator const& collision, + FiltMftTracks const& tracks) { + processData(collision, tracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processDataCent, + "Count tracks in FT0C bins", false); + + /// @brief process fnc. to run on DATA and REC MC based on BestCollisionsFwd + /// table w/o centrality selection + void processDatawBestTracksInclusive( + Colls::iterator const& collision, FiltMftTracks const& tracks, + soa::SmallGroups const& besttracks) { + processDatawBestTracks(collision, tracks, besttracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processDatawBestTracksInclusive, + "Count tracks based on BestCollisionsFwd table", false); + + /// @brief process fnc. to run on DATA and REC MC based on BestCollisionsFwd + /// table w/ FT0C centrality selection + void processDatawBestTracksCent( + CollsCent::iterator const& collision, FiltMftTracks const& tracks, + soa::SmallGroups const& besttracks) { + processDatawBestTracks(collision, tracks, besttracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processDatawBestTracksCent, + "Count tracks in FT0C bins based on BestCollisionsFwd table", + false); + + Preslice perCol = o2::aod::fwdtrack::collisionId; + Partition mcSample = nabs(aod::mcparticle::eta) < 1.0f; + + /// @brief process template function to run on MC truth + /// @param cols subscribe to the collisions + /// @param parts subscribe to filtered MC particle table + template + void processMC( + typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks) { + float cgen = -1; + bool atLeastOne = false; + int moreThanOne = 0; + for (auto const& collision : collisions) { + float crec = -1; + if constexpr (C::template contains()) { + crec = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., crec); + } else { + registry.fill(HIST("Events/EvtEffGen"), 1.); + } + + if (isGoodEvent(collision)) { + if constexpr (C::template contains()) { + if (!atLeastOne) { + cgen = crec; + } + } + atLeastOne = true; + ++moreThanOne; + auto z = collision.posZ(); + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., crec); + registry.fill(HIST("Events/Centrality/hRecCent"), crec); + registry.fill(HIST("Events/Centrality/hRecZvtxCent"), z, crec); + } else { + registry.fill(HIST("Events/EvtEffGen"), 2.); + } + + auto perCollisionSample = + tracks.sliceBy(perCol, collision.globalIndex()); + auto nTrkRec = + countTracks(perCollisionSample, z, crec, + collision.trackOccupancyInTimeRange()); + + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Events/Centrality/ZvtxDiff"), + collision.posZ() - mcCollision.posZ(), crec); + } else { + qaregistry.fill(HIST("Events/ZvtxDiff"), + collision.posZ() - mcCollision.posZ()); + } + + if (useZDiffCut) { + if (std::abs(collision.posZ() - mcCollision.posZ()) > maxZvtxDiff) { + continue; + } + } + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, + collision.posZ(), crec); + } else { + registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, collision.posZ()); + } + } + } + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., cgen); + } else { + registry.fill(HIST("Events/EvtEffGen"), 3.); + } + + auto perCollMCsample = mcSample->sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + auto nchrg = countPart(perCollMCsample); + if (moreThanOne > 1) { + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Events/Centrality/SplitMult"), nchrg, cgen); + } else { + qaregistry.fill(HIST("Events/SplitMult"), nchrg); + } + } + + auto zvtxMC = mcCollision.posZ(); + auto nCharged = countPart(particles); + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, zvtxMC, + cgen); + } else { + registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); + } + + fillHistMC()>(particles, cgen, + zvtxMC, atLeastOne); + + if (collisions.size() == 0) { + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), + mcCollision.posZ(), cgen); + } else { + qaregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + } + } + } + + /// @brief process fnc. to run on MC w/o centrality selection + void processMCInclusive( + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks) { + processMC(mccollision, collisions, particles, + tracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processMCInclusive, + "Count MC particles", false); + + /// @brief process fnc. to run on MC w FT0C centrality selection + void processMCCent( + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks) { + processMC(mccollision, collisions, particles, + tracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processMCCent, + "Count MC particles in FT0C bins", false); + + PresliceUnsorted perColU = + aod::fwdtrack::bestCollisionId; + + /// @brief process template function to run on MC truth using + /// aod::BestCollisionsFwd tracks + template + void processMCwBestTracks( + typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks, + FiltBestTracks const& besttracks) { + float cgen = -1; + bool atLeastOne = false; + // int moreThanOne = 0; + for (auto const& collision : collisions) { + float crec = -1; + if constexpr (C::template contains()) { + crec = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., crec); + } else { + registry.fill(HIST("Events/EvtEffGen"), 1.); + } + + if (isGoodEvent(collision)) { + if constexpr (C::template contains()) { + if (!atLeastOne) { + cgen = crec; + } + } + atLeastOne = true; + // ++moreThanOne; + auto z = collision.posZ(); + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., crec); + } else { + registry.fill(HIST("Events/EvtEffGen"), 2.); + } + + 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 (C::template contains()) { + registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, + crec); + } else { + registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, z); + } + } + } + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., cgen); + } else { + registry.fill(HIST("Events/EvtEffGen"), 3.); + } + + auto zvtxMC = mcCollision.posZ(); + auto nCharged = countPart(particles); + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/NtrkZvtxGen_t"), nCharged, zvtxMC, + cgen); + } else { + registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); + } + + fillHistMC()>(particles, cgen, + zvtxMC, atLeastOne); + + if (collisions.size() == 0) { + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), + mcCollision.posZ(), cgen); + } else { + qaregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + } + } + } + + /// @brief process fnc. to run on MC (inclusive, using aod::BestCollisionsFwd + /// tracks) + void processMCwBestTracksInclusive( + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks, + // aod::BestCollisionsFwd const + // &besttracks + FiltBestTracks const& besttracks) { + processMCwBestTracks( + mccollision, collisions, particles, tracks, besttracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processMCwBestTracksInclusive, + "Count MC particles using aod::BestCollisionsFwd", false); + + /// @brief process fnc. to run on MC (FT0C centrality, using + /// aod::BestCollisionsFwd tracks) + void processMCwBestTracksCent( + aod::McCollisions::iterator const& mccollision, + soa::SmallGroups> const& collisions, + FiltParticles const& particles, FiltMcMftTracks const& tracks, + FiltBestTracks const& besttracks) { + processMCwBestTracks( + mccollision, collisions, particles, tracks, besttracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processMCwBestTracksCent, + "Count MC particles in FT0C bins using aod::BestCollisionsFwd", + false); + + using ParticlesI = soa::Join; + Partition primariesI = + ((aod::mcparticle::flags & + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary) == + (uint8_t)o2::aod::mcparticle::enums::PhysicalPrimary); + + /// @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) { + for (auto const& collision : collisions) { + if (!isGoodEvent(collision)) { + continue; + } + if (!collision.has_mcCollision()) { + continue; + } + + float crec = -1; + if constexpr (C::template contains()) { + crec = collision.centFT0C(); + } + + auto mcCollision = collision.mcCollision(); + auto particlesPerCol = primariesI->sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + particlesPerCol.bindExternalIndices(&tracks); + + for (auto const& particle : particlesPerCol) { + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + // MC gen + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGen"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); + } else { + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffGen"), particle.pt(), + particle.phi(), particle.eta(), mcCollision.posZ()); + } + // MC rec + if (particle.has_mfttracks()) { + auto iscounted = false; + auto ncnt = 0; + auto relatedTracks = + particle.template mfttracks_as(); + for (auto const& track : relatedTracks) { + if (!isTrackSelected(track)) { + continue; + } + ++ncnt; + if constexpr (C::template contains()) { + if (!iscounted) { // primaries + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffRec"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); + iscounted = true; + } + if (ncnt > 1) { // duplicates + qaregistry.fill(HIST("Tracks/Centrality/hPhiEtaDuplicates"), + track.phi(), track.eta(), crec); + qaregistry.fill( + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); + } + } else { + if (!iscounted) { // primaries + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffRec"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ()); + iscounted = true; + } + if (ncnt > 1) { // duplicates + qaregistry.fill(HIST("Tracks/hPhiEtaDuplicates"), track.phi(), + track.eta()); + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ()); + } + } + } + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Tracks/Centrality/NmftTrkPerPart"), ncnt, + crec); + } else { + qaregistry.fill(HIST("Tracks/NmftTrkPerPart"), ncnt); + } + if (relatedTracks.size() > 1) { + if constexpr (C::template contains()) { + qaregistry.fill( + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); + } else { + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffGenDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ()); + } + } + } + } + } + } + + /// @brief process function to calculate tracking efficiency (inclusive, + /// indexed) + void processTrkEffIdxInlusive( + soa::Join const& collisions, + aod::McCollisions const& mccollisions, ParticlesI const& particles, + MFTTracksLabeled const& tracks) { + processTrkEffIdx(collisions, mccollisions, + particles, tracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processTrkEffIdxInlusive, + "Process tracking efficiency (inclusive)", false); + + /// @brief process function to calculate tracking efficiency (FT0 bins, + /// indexed) + void processTrkEffIdxCent( + soa::Join const& collisions, + aod::McCollisions const& mccollisions, ParticlesI const& particles, + MFTTracksLabeled const& tracks) { + processTrkEffIdx(collisions, mccollisions, + particles, tracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processTrkEffIdxCent, + "Process tracking efficiency in FT0 bins", false); + + /// @brief process function to calculate tracking efficiency (indexed) based + /// on BestCollisionsFwd in FT0C bins + template + void processTrkEffBest( + typename soa::Join::iterator const& collision, + MC const& /*mccollisions*/, FiltParticles const& particles, + FiltMcMftTracks const& /*tracks*/, + soa::SmallGroups const& besttracks) { + if (!isGoodEvent(collision)) { + return; + } + if (!collision.has_mcCollision()) { + return; + } + + float crec = -1; + if constexpr (C::template contains()) { + crec = collision.centFT0C(); + } + + auto mcCollision = collision.mcCollision(); + auto particlesPerCol = particles.sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + for (auto const& particle : particlesPerCol) { + if (!isChrgParticle(particle.pdgCode())) { + continue; + } + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestGen"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); + } else { + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestGen"), particle.pt(), + particle.phi(), particle.eta(), mcCollision.posZ()); + } + } + + for (auto const& track : besttracks) { + auto itrack = track.mfttrack_as(); + if (!isTrackSelected(itrack)) { + continue; + } + if (itrack.has_mcParticle()) { + auto particle = itrack.mcParticle_as(); + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Tracks/Centrality/hPtPhiEtaZvtxEffBestRec"), + particle.pt(), itrack.phi(), itrack.eta(), + mcCollision.posZ(), crec); + } else { + qaregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffBestRec"), particle.pt(), + itrack.phi(), itrack.eta(), mcCollision.posZ()); + } + } else { + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Tracks/Centrality/hPtEffBestFakeRec"), + itrack.pt(), crec); + } else { + qaregistry.fill(HIST("Tracks/hPtEffBestFakeRec"), itrack.pt()); + } + } + } + } + + /// @brief process function to calculate tracking efficiency (inclusive, based + /// on BestCollisionsFwd) + void processTrkEffBestInclusive( + soa::Join::iterator const& collision, + aod::McCollisions const& mccollisions, FiltParticles const& particles, + FiltMcMftTracks const& tracks, + soa::SmallGroups const& besttracks) { + processTrkEffBest(collision, mccollisions, + particles, tracks, besttracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processTrkEffBestInclusive, + "Process tracking efficiency (inclusive, based on BestCollisionsFwd)", + false); + + /// @brief process function to calculate tracking efficiency (in FT0 bins, + /// based on BestCollisionsFwd) + void processTrkEffBestCent( + soa::Join::iterator const& collision, + aod::McCollisions const& mccollisions, FiltParticles const& particles, + FiltMcMftTracks const& tracks, + soa::SmallGroups const& besttracks) { + processTrkEffBest( + collision, mccollisions, particles, tracks, besttracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processTrkEffBestCent, + "Process tracking efficiency (in FT0 bins, based on BestCollisionsFwd)", + false); + + Preslice filtTrkperCol = o2::aod::fwdtrack::collisionId; + + /// @brief process template function for MC QA checks + template + void processMcQA( + typename soa::SmallGroups> const + &collisions, + aod::McCollisions const& mcCollisions, + FiltParticles const& /*particles*/, MFTTracksLabeled const& tracks, + aod::AmbiguousMFTTracks const& atracks) { + for (const auto& collision : collisions) { + float crec = -1; + if constexpr (C::template contains()) { + crec = collision.centFT0C(); + qaregistry.fill( + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), crec); + } else { + qaregistry.fill(HIST("Events/hRecPerGenColls"), + static_cast(collisions.size()) / + mcCollisions.size()); + } + + 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; + } + } + } + if constexpr (C::template contains()) { + qaregistry.fill(HIST("Tracks/Centrality/hNmftTrks"), ntracks, crec); + qaregistry.fill(HIST("Tracks/Centrality/hFracAmbiguousMftTrks"), + static_cast(nAtracks) / ntracks, crec); + } else { + qaregistry.fill(HIST("Tracks/hNmftTrks"), ntracks); + qaregistry.fill(HIST("Tracks/hFracAmbiguousMftTrks"), + static_cast(nAtracks) / ntracks); + } + } + } + + /// @brief process function for QA checks (inclusive) + void processMcQAInclusive( + soa::SmallGroups> const& collisions, + aod::McCollisions const& mcCollisions, FiltParticles const& particles, + MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) { + processMcQA(collisions, mcCollisions, particles, tracks, atracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processMcQAInclusive, + "Process MC QA checks (inclusive)", false); + + /// @brief process function for QA checks (in FT0 bins) + void processMcQACent( + soa::SmallGroups> const& collisions, + aod::McCollisions const& mcCollisions, FiltParticles const& particles, + MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) { + processMcQA(collisions, mcCollisions, particles, tracks, + atracks); + } + + PROCESS_SWITCH(PseudorapidityDensityMFT, processMcQACent, + "Process MC QA checks (in FT0 bins)", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +}