From f730a30d5191879f1e9e4a3476c9802767b0b19f Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 13 Nov 2024 10:15:33 +0100 Subject: [PATCH 1/6] [PWGLF] Add new task for MFT Pb-Pb --- PWGMM/Mult/Tasks/CMakeLists.txt | 5 + PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 1504 ++++++++++++++++++++++++++ 2 files changed, 1509 insertions(+) create mode 100644 PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx diff --git a/PWGMM/Mult/Tasks/CMakeLists.txt b/PWGMM/Mult/Tasks/CMakeLists.txt index 4828a7ea434..35ff48fc786 100644 --- a/PWGMM/Mult/Tasks/CMakeLists.txt +++ b/PWGMM/Mult/Tasks/CMakeLists.txt @@ -34,6 +34,11 @@ o2physics_add_dpl_workflow(dndeta-mft PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(dndeta-mft-pbpb + SOURCES dndeta-mft-pbpb.cxx + PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(flatenicity-fv0 SOURCES flatenicityFV0.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx new file mode 100644 index 00000000000..2f2454b2e58 --- /dev/null +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -0,0 +1,1504 @@ +// 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. + +/// +/// \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 +/// + +#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 + +#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 PseudorapidityDensityMFT { + 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 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"}; + } 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, + "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, {{1000, 0, 100}}}, + 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 - collision + Filter filterCollCent = nabs(aod::cent::centFT0C) < cfgCutCent; + Filter filterCollZvtx = nabs(aod::collision::posZ) < cfgCutZvtx; + Filter filterMcCollZvtx = nabs(aod::mccollision::posZ) < cfgCutZvtx; + + /// Filters - tracks + Filter filtTrkEta = (aod::fwdtrack::eta < trkcuts.cfg_eta_max) && + (aod::fwdtrack::eta > trkcuts.cfg_eta_min); + Filter filtATrackID = (aod::fwdtrack::bestCollisionId >= 0); + Filter filtATrackDCA = + (nabs(aod::fwdtrack::bestDCAXY) < trkcuts.cfg_max_dcaxy); + + /// 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 filtColls = soa::Filtered>; + using filtColl = + soa::Filtered>::iterator; + using filtCollsCent = + soa::Filtered>; + using filtCollCent = soa::Filtered< + soa::Join>::iterator; + using CollsGenCentSmallG = + o2::soa::SmallGroups>; + using filtCollsGenCentSmallG = + soa::SmallGroups>; + using filtCollsGenCent = + soa::Filtered>; + using filtMcGenColls = soa::Filtered; + using filtMcGenColl = soa::Filtered::iterator; + using filtMftTracks = soa::Filtered; + using filtMcMftTracks = soa::Filtered; + using filtBestTracks = soa::Filtered; + using filtBestTracksJ = + 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) + return false; + if (trkcuts.cfg_require_ca && !track.isCA()) + return false; + if (track.nClusters() < trkcuts.cfg_min_ncluster_mft) + return false; + if (track.pt() < trkcuts.cfg_min_pt) + return false; + if (usePhiCut) { + float phi = track.phi(); + o2::math_utils::bringTo02Pi(phi); + if (phi < 0.f || 2.f * M_PI < 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))) + 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 &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 || 2.f * M_PI < 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 &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 || 2.f * M_PI < 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 &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 fillHist_MC(P const &particles, float cent, float zvtx, + bool const atLeastOne) { + for (auto &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) { + 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 || 2.f * M_PI < 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 &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) { + 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(filtColls::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(filtCollsCent::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( + filtColls::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( + filtCollsCent::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 c_gen = -1; + bool atLeastOne = false; + int moreThanOne = 0; + for (auto &collision : collisions) { + float c_rec = -1; + if constexpr (C::template contains()) { + c_rec = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., c_rec); + } else { + registry.fill(HIST("Events/EvtEffGen"), 1.); + } + + if (isGoodEvent(collision)) { + if constexpr (C::template contains()) { + if (!atLeastOne) { + c_gen = c_rec; + } + } + atLeastOne = true; + ++moreThanOne; + 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); + } else { + registry.fill(HIST("Events/EvtEffGen"), 2.); + } + + auto perCollisionSample = + tracks.sliceBy(perCol, collision.globalIndex()); + auto nTrkRec = + countTracks(perCollisionSample, z, c_rec, + collision.trackOccupancyInTimeRange()); + + if constexpr (C::template contains()) { + QAregistry.fill(HIST("Events/Centrality/ZvtxDiff"), + collision.posZ() - mcCollision.posZ(), c_rec); + } 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(), c_rec); + } else { + registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, collision.posZ()); + } + } + } + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., c_gen); + } 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, c_gen); + } 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, + c_gen); + } else { + registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); + } + + fillHist_MC()>(particles, c_gen, + zvtxMC, atLeastOne); + + if (collisions.size() == 0) { + if constexpr (C::template contains()) { + QAregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), + mcCollision.posZ(), c_gen); + } else { + QAregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + } + } + } + + /// @brief process fnc. to run on MC w/o centrality selection + void processMCInclusive( + filtMcGenColls::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( + filtMcGenColls::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 c_gen = -1; + bool atLeastOne = false; + int moreThanOne = 0; + for (auto &collision : collisions) { + float c_rec = -1; + if constexpr (C::template contains()) { + c_rec = collision.centFT0C(); + registry.fill(HIST("Events/Centrality/EvtEffGen"), 1., c_rec); + } else { + registry.fill(HIST("Events/EvtEffGen"), 1.); + } + + if (isGoodEvent(collision)) { + if constexpr (C::template contains()) { + if (!atLeastOne) { + c_gen = c_rec; + } + } + atLeastOne = true; + ++moreThanOne; + auto z = collision.posZ(); + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/EvtEffGen"), 2., c_rec); + } 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, c_rec, + collision.trackOccupancyInTimeRange()); + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, + c_rec); + } else { + registry.fill(HIST("Events/NtrkZvtxGen"), nTrkRec, z); + } + } + } + + if constexpr (C::template contains()) { + registry.fill(HIST("Events/Centrality/EvtEffGen"), 3., c_gen); + } 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, + c_gen); + } else { + registry.fill(HIST("Events/NtrkZvtxGen_t"), nCharged, zvtxMC); + } + + fillHist_MC()>(particles, c_gen, + zvtxMC, atLeastOne); + + if (collisions.size() == 0) { + if constexpr (C::template contains()) { + QAregistry.fill(HIST("Events/Centrality/NotFoundEventZvtx"), + mcCollision.posZ(), c_gen); + } else { + QAregistry.fill(HIST("Events/NotFoundEventZvtx"), mcCollision.posZ()); + } + } + } + + /// @brief process fnc. to run on MC (inclusive, using aod::BestCollisionsFwd + /// tracks) + void processMCwBestTracksInclusive( + filtMcGenColls::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( + filtMcGenColls::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::Filtered> const + &collisions, + MC const & /*mccollisions*/, ParticlesI const & /*particles*/, + MFTTracksLabeled const &tracks) { + for (auto &collision : collisions) { + if (!isGoodEvent(collision)) { + continue; + } + if (!collision.has_mcCollision()) { + continue; + } + + float c_rec = -1; + if constexpr (C::template contains()) { + c_rec = collision.centFT0C(); + } + + auto mcCollision = collision.mcCollision(); + auto particlesPerCol = primariesI->sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + particlesPerCol.bindExternalIndices(&tracks); + + for (auto &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(), c_rec); + } 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 &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(), c_rec); + 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); + } + } 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, + c_rec); + } 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(), c_rec); + } 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::Filtered> 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::Filtered> 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::Filtered< + 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 c_rec = -1; + if constexpr (C::template contains()) { + c_rec = collision.centFT0C(); + } + + auto mcCollision = collision.mcCollision(); + auto particlesPerCol = particles.sliceByCached( + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + for (auto &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(), c_rec); + } 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(), c_rec); + } 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(), c_rec); + } else { + QAregistry.fill(HIST("Tracks/hPtEffBestFakeRec"), itrack.pt()); + } + } + } + } + + /// @brief process function to calculate tracking efficiency (inclusive, based + /// on BestCollisionsFwd) + void processTrkEffBestInclusive( + soa::Filtered>::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::Filtered>:: + 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, + filtMcGenColls const &mcCollisions, filtParticles const & /*particles*/, + MFTTracksLabeled const &tracks, aod::AmbiguousMFTTracks const &atracks) { + for (const auto &collision : collisions) { + float c_rec = -1; + if constexpr (C::template contains()) { + c_rec = collision.centFT0C(); + QAregistry.fill(HIST("Events/Centrality/hRecPerGenColls"), + float(collisions.size()) / mcCollisions.size(), c_rec); + } else { + QAregistry.fill(HIST("Events/hRecPerGenColls"), + float(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, c_rec); + QAregistry.fill(HIST("Tracks/Centrality/hFracAmbiguousMftTrks"), + float(Natracks) / Ntracks, c_rec); + } else { + QAregistry.fill(HIST("Tracks/hNmftTrks"), Ntracks); + QAregistry.fill(HIST("Tracks/hFracAmbiguousMftTrks"), + float(Natracks) / Ntracks); + } + } + } + + /// @brief process function for QA checks (inclusive) + void processMcQAInclusive( + soa::SmallGroups> const + &collisions, + filtMcGenColls 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, + filtMcGenColls 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)}; +} From c3f19c90075bae295b01524cf6368bdf0d5f5270 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 13 Nov 2024 10:59:27 +0100 Subject: [PATCH 2/6] Fix formatting --- PWGMM/Mult/Tasks/CMakeLists.txt | 2 +- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/PWGMM/Mult/Tasks/CMakeLists.txt b/PWGMM/Mult/Tasks/CMakeLists.txt index 35ff48fc786..9012d14f2c1 100644 --- a/PWGMM/Mult/Tasks/CMakeLists.txt +++ b/PWGMM/Mult/Tasks/CMakeLists.txt @@ -38,7 +38,7 @@ o2physics_add_dpl_workflow(dndeta-mft-pbpb SOURCES dndeta-mft-pbpb.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore COMPONENT_NAME Analysis) - + o2physics_add_dpl_workflow(flatenicity-fv0 SOURCES flatenicityFV0.cxx PUBLIC_LINK_LIBRARIES O2::Framework O2Physics::AnalysisCore diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index 2f2454b2e58..a729f28fb06 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -1,6 +1,6 @@ // 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. +// 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". From 3487754bb30af652c548c2b2037f9b4b0e283b83 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 13 Nov 2024 11:10:58 +0100 Subject: [PATCH 3/6] fix header --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index a729f28fb06..24f5f1083f5 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -39,7 +39,6 @@ #include "MathUtils/Utils.h" #include "ReconstructionDataFormats/GlobalTrackID.h" -#include #include #include "Index.h" From 8c047e20e123966621f0b08dfff4e093b5d66f89 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 13 Nov 2024 11:19:54 +0100 Subject: [PATCH 4/6] fix includes and casting --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index 24f5f1083f5..5807cf8cc1a 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -20,6 +20,7 @@ #include #include +#include #include "Framework/ASoAHelpers.h" #include "Framework/AnalysisDataModel.h" @@ -1438,10 +1439,10 @@ struct PseudorapidityDensityMFT { if constexpr (C::template contains()) { c_rec = collision.centFT0C(); QAregistry.fill(HIST("Events/Centrality/hRecPerGenColls"), - float(collisions.size()) / mcCollisions.size(), c_rec); + static_cast(collisions.size()) / mcCollisions.size(), c_rec); } else { QAregistry.fill(HIST("Events/hRecPerGenColls"), - float(collisions.size()) / mcCollisions.size()); + static_cast(collisions.size()) / mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1462,11 +1463,11 @@ struct PseudorapidityDensityMFT { if constexpr (C::template contains()) { QAregistry.fill(HIST("Tracks/Centrality/hNmftTrks"), Ntracks, c_rec); QAregistry.fill(HIST("Tracks/Centrality/hFracAmbiguousMftTrks"), - float(Natracks) / Ntracks, c_rec); + static_cast(Natracks) / Ntracks, c_rec); } else { QAregistry.fill(HIST("Tracks/hNmftTrks"), Ntracks); QAregistry.fill(HIST("Tracks/hFracAmbiguousMftTrks"), - float(Natracks) / Ntracks); + static_cast(Natracks) / Ntracks); } } } From d3aac26bb97bb316cc9c5204918b0f7367e4a511 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 13 Nov 2024 12:05:37 +0100 Subject: [PATCH 5/6] fix clang-format --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index 5807cf8cc1a..b3532dfef0d 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -64,7 +64,9 @@ struct PseudorapidityDensityMFT { // Histogram registry HistogramRegistry registry{ - "registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + "registry", + {}, + OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry QAregistry{ "QAregistry", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; From 9aa4d4ccd9e26ab8ddcb1be7b633242f2da05f91 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 13 Nov 2024 11:06:28 +0000 Subject: [PATCH 6/6] Please consider the following formatting changes --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 457 ++++++++++++++------------- 1 file changed, 244 insertions(+), 213 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index b3532dfef0d..a800b3a1002 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -68,7 +68,11 @@ struct PseudorapidityDensityMFT { {}, OutputObjHandlingPolicy::AnalysisObject}; HistogramRegistry QAregistry{ - "QAregistry", {}, OutputObjHandlingPolicy::AnalysisObject, false, true}; + "QAregistry", + {}, + OutputObjHandlingPolicy::AnalysisObject, + false, + true}; // analysis specific conf. Configurable usePhiCut{"usePhiCut", false, "use azimuthal angle cut"}; @@ -84,8 +88,8 @@ struct PseudorapidityDensityMFT { 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"}; + "cfg_require_ca", false, + "Use Cellular Automaton track-finding algorithm"}; Configurable cfg_max_dcaxy{"cfg_max_dcaxy", 2.0f, "Cut on dcaXY"}; } trkcuts; @@ -96,57 +100,62 @@ struct PseudorapidityDensityMFT { Configurable useZDiffCut{"useZvtxDiffCut", false, "use Zvtx reco-mc diff. cut"}; Configurable maxZvtxDiff{ - "maxZvtxDiff", 1.0f, - "max allowed Z vtx difference for reconstruced collisions (cm)"}; + "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"}; + "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"}; + "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"}; + "minOccupancy", -1, "minimum occupancy from neighbouring collisions"}; Configurable maxOccupancy{ - "maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; + "maxOccupancy", -1, "maximum occupancy from neighbouring collisions"}; ConfigurableAxis CentBins{ - "CentBins", - {VARIABLE_WIDTH, 0, 5, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100}, - ""}; + "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, @@ -175,7 +184,7 @@ struct PseudorapidityDensityMFT { ";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"); @@ -192,7 +201,7 @@ struct PseudorapidityDensityMFT { "; #chi^{2}; #it{#eta};", {HistType::kTH2F, {{600, 0, 20}, {100, -8, 8}}}}); QAregistry.add( - {"Tracks/Chi2", "; #chi^{2};", {HistType::kTH1F, {{600, 0, 20}}}}); + {"Tracks/Chi2", "; #chi^{2};", {HistType::kTH1F, {{600, 0, 20}}}}); QAregistry.add({"Tracks/NclustersEta", "; nClusters; #eta;", {HistType::kTH2F, {{7, 4, 10}, {100, -8, 8}}}}); @@ -235,7 +244,7 @@ struct PseudorapidityDensityMFT { ";status;centrality;events", {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"); @@ -253,9 +262,9 @@ struct PseudorapidityDensityMFT { {HistType::kTH1F, {{1000, 0, 100}}}, true}); QAregistry.add( - {"Tracks/Centrality/Chi2Eta", - "; #chi^{2}; #it{#eta}; centrality", - {HistType::kTH3F, {{600, 0, 20}, {100, -8, 8}, CentAxis}}}); + {"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}}}); @@ -280,9 +289,9 @@ struct PseudorapidityDensityMFT { "; #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}}}); + {"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}}}); @@ -313,7 +322,7 @@ 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"); @@ -343,7 +352,7 @@ struct PseudorapidityDensityMFT { " ; Z_{rec} - Z_{gen} (cm)", {HistType::kTH1F, {DeltaZAxis}}}); QAregistry.add( - {"Events/SplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); + {"Events/SplitMult", " ; N_{gen}", {HistType::kTH1F, {MultAxis}}}); } if (doprocessMCCent || doprocessMCwBestTracksCent) { @@ -351,7 +360,7 @@ struct PseudorapidityDensityMFT { ";status;events", {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"); @@ -393,24 +402,24 @@ struct PseudorapidityDensityMFT { if (doprocessTrkEffIdxInlusive) { QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffGen", - "hPtPhiEtaZvtxEffGen", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); + {"Tracks/hPtPhiEtaZvtxEffGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffRec", - "hPtPhiEtaZvtxEffRec", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); + {"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}}}); + {"Tracks/hPtPhiEtaZvtxEffDuplicates", + "hPtPhiEtaZvtxEffDuplicates", + {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffGenDuplicates", - "hPtPhiEtaZvtxEffGenDuplicates", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); + {"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.}}}}); @@ -443,13 +452,13 @@ struct PseudorapidityDensityMFT { if (doprocessTrkEffBestInclusive) { QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffBestGen", - "hPtPhiEtaZvtxEffGen", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); + {"Tracks/hPtPhiEtaZvtxEffBestGen", + "hPtPhiEtaZvtxEffGen", + {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); QAregistry.add( - {"Tracks/hPtPhiEtaZvtxEffBestRec", - "hPtPhiEtaZvtxEffRec", - {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); + {"Tracks/hPtPhiEtaZvtxEffBestRec", + "hPtPhiEtaZvtxEffRec", + {HistType::kTHnSparseF, {PtAxis, PhiAxis, EtaAxis, ZAxis}}}); QAregistry.add({"Tracks/hPtEffBestFakeRec", " ; p_{T} (GeV/c);", {HistType::kTH1F, {PtAxis}}}); @@ -483,16 +492,16 @@ struct PseudorapidityDensityMFT { if (doprocessMcQACent) { QAregistry.add( - {"Events/Centrality/hRecPerGenColls", - "; #it{N}_{reco collisions} / #it{N}_{gen collisions}; centrality", - {HistType::kTH2F, {{200, 0., 2.}, CentAxis}}}); + {"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}}}); + {"Tracks/Centrality/hFracAmbiguousMftTrks", + "; #it{N}_{ambiguous tracks} / #it{N}_{tracks}; centrality", + {HistType::kTH2F, {{100, 0., 1.}, CentAxis}}}); } } @@ -506,7 +515,7 @@ struct PseudorapidityDensityMFT { (aod::fwdtrack::eta > trkcuts.cfg_eta_min); Filter filtATrackID = (aod::fwdtrack::bestCollisionId >= 0); Filter filtATrackDCA = - (nabs(aod::fwdtrack::bestDCAXY) < trkcuts.cfg_max_dcaxy); + (nabs(aod::fwdtrack::bestDCAXY) < trkcuts.cfg_max_dcaxy); /// Filters - mc particles Filter primaries = (aod::mcparticle::flags & @@ -516,7 +525,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; @@ -529,29 +538,31 @@ struct PseudorapidityDensityMFT { /// Filtered tables using filtColls = soa::Filtered>; using filtColl = - soa::Filtered>::iterator; + soa::Filtered>::iterator; using filtCollsCent = - soa::Filtered>; + soa::Filtered>; using filtCollCent = soa::Filtered< - soa::Join>::iterator; + soa::Join>::iterator; using CollsGenCentSmallG = - o2::soa::SmallGroups>; + o2::soa::SmallGroups>; using filtCollsGenCentSmallG = - soa::SmallGroups>; + soa::SmallGroups>; using filtCollsGenCent = - soa::Filtered>; + soa::Filtered>; using filtMcGenColls = soa::Filtered; using filtMcGenColl = soa::Filtered::iterator; using filtMftTracks = soa::Filtered; using filtMcMftTracks = soa::Filtered; using filtBestTracks = soa::Filtered; using filtBestTracksJ = - soa::Filtered>; + soa::Filtered>; using filtParticles = soa::Filtered; - template bool isTrackSelected(const T &track) { + template + bool isTrackSelected(const T& track) + { if (track.eta() < trkcuts.cfg_eta_min || track.eta() > trkcuts.cfg_eta_max) return false; if (trkcuts.cfg_require_ca && !track.isCA()) @@ -577,10 +588,11 @@ struct PseudorapidityDensityMFT { } 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& track : tracks) { if (fillHis) { if constexpr (C::template contains()) { QAregistry.fill(HIST("Tracks/Centrality/Chi2Eta"), track.chi2(), @@ -622,11 +634,12 @@ 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& atrack : besttracks) { auto itrack = atrack.template mfttrack_as(); if (!isTrackSelected(itrack)) { continue; @@ -679,9 +692,11 @@ 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& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; } @@ -691,7 +706,8 @@ struct PseudorapidityDensityMFT { } template - bool isGoodEvent(C const &collision) { + bool isGoodEvent(C const& collision) + { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -752,7 +768,8 @@ 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) { @@ -762,9 +779,10 @@ struct PseudorapidityDensityMFT { } template - void fillHist_MC(P const &particles, float cent, float zvtx, - bool const atLeastOne) { - for (auto &particle : particles) { + void fillHist_MC(P const& particles, float cent, float zvtx, + bool const atLeastOne) + { + for (auto& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; } @@ -804,14 +822,15 @@ 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& 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& collision : collisions) { if (collision.has_foundBC()) { if (collision.foundBCId() == bc.globalIndex()) { cols.emplace_back(collision); @@ -835,8 +854,9 @@ struct PseudorapidityDensityMFT { "Collect event sample stats", true); template - void processData(typename C::iterator const &collision, - filtMftTracks const &tracks) { + void processData(typename C::iterator const& collision, + filtMftTracks const& tracks) + { float c = -1; if constexpr (C::template contains()) { c = collision.centFT0C(); @@ -858,7 +878,7 @@ struct PseudorapidityDensityMFT { } 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 { @@ -868,8 +888,9 @@ 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(); @@ -890,8 +911,8 @@ struct PseudorapidityDensityMFT { } 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 { @@ -900,8 +921,9 @@ struct PseudorapidityDensityMFT { } /// @brief process fnc. to run on DATA and REC MC w/o centrality selection - void processDataInclusive(filtColls::iterator const &collision, - filtMftTracks const &tracks) { + void processDataInclusive(filtColls::iterator const& collision, + filtMftTracks const& tracks) + { processData(collision, tracks); } @@ -909,8 +931,9 @@ struct PseudorapidityDensityMFT { false); /// @brief process fnc. to run on DATA and REC MC w/ FT0C centrality selection - void processDataCent(filtCollsCent::iterator const &collision, - filtMftTracks const &tracks) { + void processDataCent(filtCollsCent::iterator const& collision, + filtMftTracks const& tracks) + { processData(collision, tracks); } @@ -920,8 +943,9 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on DATA and REC MC based on BestCollisionsFwd /// table w/o centrality selection void processDatawBestTracksInclusive( - filtColls::iterator const &collision, filtMftTracks const &tracks, - soa::SmallGroups const &besttracks) { + filtColls::iterator const& collision, filtMftTracks const& tracks, + soa::SmallGroups const& besttracks) + { processDatawBestTracks(collision, tracks, besttracks); } @@ -931,8 +955,9 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on DATA and REC MC based on BestCollisionsFwd /// table w/ FT0C centrality selection void processDatawBestTracksCent( - filtCollsCent::iterator const &collision, filtMftTracks const &tracks, - soa::SmallGroups const &besttracks) { + filtCollsCent::iterator const& collision, filtMftTracks const& tracks, + soa::SmallGroups const& besttracks) + { processDatawBestTracks(collision, tracks, besttracks); } @@ -948,13 +973,14 @@ struct PseudorapidityDensityMFT { /// @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) { + typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + filtParticles const& particles, filtMcMftTracks const& tracks) + { float c_gen = -1; bool atLeastOne = false; int moreThanOne = 0; - for (auto &collision : collisions) { + for (auto& collision : collisions) { float c_rec = -1; if constexpr (C::template contains()) { c_rec = collision.centFT0C(); @@ -982,10 +1008,10 @@ struct PseudorapidityDensityMFT { } auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); + tracks.sliceBy(perCol, collision.globalIndex()); auto nTrkRec = - countTracks(perCollisionSample, z, c_rec, - collision.trackOccupancyInTimeRange()); + countTracks(perCollisionSample, z, c_rec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { QAregistry.fill(HIST("Events/Centrality/ZvtxDiff"), @@ -1017,7 +1043,7 @@ struct PseudorapidityDensityMFT { } auto perCollMCsample = mcSample->sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); auto Nchrg = countPart(perCollMCsample); if (moreThanOne > 1) { if constexpr (C::template contains()) { @@ -1051,10 +1077,10 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on MC w/o centrality selection void processMCInclusive( - filtMcGenColls::iterator const &mccollision, - soa::SmallGroups> const - &collisions, - filtParticles const &particles, filtMcMftTracks const &tracks) { + filtMcGenColls::iterator const& mccollision, + soa::SmallGroups> const& collisions, + filtParticles const& particles, filtMcMftTracks const& tracks) + { processMC(mccollision, collisions, particles, tracks); } @@ -1064,10 +1090,10 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on MC w FT0C centrality selection void processMCCent( - filtMcGenColls::iterator const &mccollision, - soa::SmallGroups> const - &collisions, - filtParticles const &particles, filtMcMftTracks const &tracks) { + filtMcGenColls::iterator const& mccollision, + soa::SmallGroups> const& collisions, + filtParticles const& particles, filtMcMftTracks const& tracks) + { processMC(mccollision, collisions, particles, tracks); } @@ -1076,20 +1102,21 @@ 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) { + typename MC::iterator const& mcCollision, + soa::SmallGroups> const& collisions, + filtParticles const& particles, filtMcMftTracks const& tracks, + filtBestTracks const& besttracks) + { float c_gen = -1; bool atLeastOne = false; int moreThanOne = 0; - for (auto &collision : collisions) { + for (auto& collision : collisions) { float c_rec = -1; if constexpr (C::template contains()) { c_rec = collision.centFT0C(); @@ -1115,12 +1142,12 @@ struct PseudorapidityDensityMFT { } 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, c_rec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, @@ -1162,15 +1189,15 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on MC (inclusive, using aod::BestCollisionsFwd /// tracks) void processMCwBestTracksInclusive( - filtMcGenColls::iterator const &mccollision, - soa::SmallGroups> const - &collisions, - filtParticles const &particles, filtMcMftTracks const &tracks, - // aod::BestCollisionsFwd const - // &besttracks - filtBestTracks const &besttracks) { + filtMcGenColls::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, @@ -1179,13 +1206,13 @@ struct PseudorapidityDensityMFT { /// @brief process fnc. to run on MC (FT0C centrality, using /// aod::BestCollisionsFwd tracks) void processMCwBestTracksCent( - filtMcGenColls::iterator const &mccollision, - soa::SmallGroups> const - &collisions, - filtParticles const &particles, filtMcMftTracks const &tracks, - filtBestTracks const &besttracks) { + filtMcGenColls::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, @@ -1194,19 +1221,19 @@ 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::Filtered> const - &collisions, - MC const & /*mccollisions*/, ParticlesI const & /*particles*/, - MFTTracksLabeled const &tracks) { - for (auto &collision : collisions) { + typename soa::Filtered> const& collisions, + MC const& /*mccollisions*/, ParticlesI const& /*particles*/, + MFTTracksLabeled const& tracks) + { + for (auto& collision : collisions) { if (!isGoodEvent(collision)) { continue; } @@ -1221,10 +1248,10 @@ struct PseudorapidityDensityMFT { 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& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; } @@ -1242,8 +1269,8 @@ struct PseudorapidityDensityMFT { auto iscounted = false; auto ncnt = 0; auto relatedTracks = - particle.template mfttracks_as(); - for (auto &track : relatedTracks) { + particle.template mfttracks_as(); + for (auto& track : relatedTracks) { if (!isTrackSelected(track)) { continue; } @@ -1259,9 +1286,9 @@ struct PseudorapidityDensityMFT { 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); + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), c_rec); } } else { if (!iscounted) { // primaries @@ -1288,9 +1315,9 @@ struct PseudorapidityDensityMFT { 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); + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), c_rec); } else { QAregistry.fill(HIST("Tracks/hPtPhiEtaZvtxEffGenDuplicates"), particle.pt(), particle.phi(), particle.eta(), @@ -1305,9 +1332,10 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (inclusive, /// indexed) void processTrkEffIdxInlusive( - soa::Filtered> const &collisions, - aod::McCollisions const &mccollisions, ParticlesI const &particles, - MFTTracksLabeled const &tracks) { + soa::Filtered> const& collisions, + aod::McCollisions const& mccollisions, ParticlesI const& particles, + MFTTracksLabeled const& tracks) + { processTrkEffIdx(collisions, mccollisions, particles, tracks); } @@ -1318,10 +1346,10 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (FT0 bins, /// indexed) void processTrkEffIdxCent( - soa::Filtered> const - &collisions, - aod::McCollisions const &mccollisions, ParticlesI const &particles, - MFTTracksLabeled const &tracks) { + soa::Filtered> const& collisions, + aod::McCollisions const& mccollisions, ParticlesI const& particles, + MFTTracksLabeled const& tracks) + { processTrkEffIdx(collisions, mccollisions, particles, tracks); } @@ -1333,11 +1361,12 @@ struct PseudorapidityDensityMFT { /// on BestCollisionsFwd in FT0C bins template void processTrkEffBest( - typename soa::Filtered< - soa::Join>::iterator const &collision, - MC const & /*mccollisions*/, filtParticles const &particles, - filtMcMftTracks const & /*tracks*/, - soa::SmallGroups const &besttracks) { + typename soa::Filtered< + soa::Join>::iterator const& collision, + MC const& /*mccollisions*/, filtParticles const& particles, + filtMcMftTracks const& /*tracks*/, + soa::SmallGroups const& besttracks) + { if (!isGoodEvent(collision)) { return; } @@ -1352,8 +1381,8 @@ struct PseudorapidityDensityMFT { 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& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; } @@ -1367,7 +1396,7 @@ struct PseudorapidityDensityMFT { } } - for (auto const &track : besttracks) { + for (auto const& track : besttracks) { auto itrack = track.mfttrack_as(); if (!isTrackSelected(itrack)) { continue; @@ -1396,47 +1425,48 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (inclusive, based /// on BestCollisionsFwd) void processTrkEffBestInclusive( - soa::Filtered>::iterator const - &collision, - aod::McCollisions const &mccollisions, filtParticles const &particles, - filtMcMftTracks const &tracks, - soa::SmallGroups const &besttracks) { + soa::Filtered>::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); + 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::Filtered>:: - iterator const &collision, - aod::McCollisions const &mccollisions, filtParticles const &particles, - filtMcMftTracks const &tracks, - soa::SmallGroups const &besttracks) { + soa::Filtered>:: + 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); + 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, - filtMcGenColls const &mcCollisions, filtParticles const & /*particles*/, - MFTTracksLabeled const &tracks, aod::AmbiguousMFTTracks const &atracks) { - for (const auto &collision : collisions) { + typename soa::SmallGroups> const& collisions, + filtMcGenColls const& mcCollisions, filtParticles const& /*particles*/, + MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) + { + for (const auto& collision : collisions) { float c_rec = -1; if constexpr (C::template contains()) { c_rec = collision.centFT0C(); @@ -1453,9 +1483,9 @@ struct PseudorapidityDensityMFT { auto trkPerColl = tracks.sliceBy(filtTrkperCol, collision.globalIndex()); uint Ntracks{0u}, Natracks{0u}; - for (const auto &track : trkPerColl) { + for (const auto& track : trkPerColl) { Ntracks++; - for (const auto &atrack : atracks) { + for (const auto& atrack : atracks) { if (atrack.mfttrackId() == track.globalIndex()) { Natracks++; break; @@ -1476,10 +1506,10 @@ struct PseudorapidityDensityMFT { /// @brief process function for QA checks (inclusive) void processMcQAInclusive( - soa::SmallGroups> const - &collisions, - filtMcGenColls const &mcCollisions, filtParticles const &particles, - MFTTracksLabeled const &tracks, aod::AmbiguousMFTTracks const &atracks) { + soa::SmallGroups> const& collisions, + filtMcGenColls const& mcCollisions, filtParticles const& particles, + MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) + { processMcQA(collisions, mcCollisions, particles, tracks, atracks); } @@ -1489,10 +1519,10 @@ struct PseudorapidityDensityMFT { /// @brief process function for QA checks (in FT0 bins) void processMcQACent( - soa::SmallGroups> const - &collisions, - filtMcGenColls const &mcCollisions, filtParticles const &particles, - MFTTracksLabeled const &tracks, aod::AmbiguousMFTTracks const &atracks) { + soa::SmallGroups> const& collisions, + filtMcGenColls const& mcCollisions, filtParticles const& particles, + MFTTracksLabeled const& tracks, aod::AmbiguousMFTTracks const& atracks) + { processMcQA(collisions, mcCollisions, particles, tracks, atracks); } @@ -1501,6 +1531,7 @@ struct PseudorapidityDensityMFT { "Process MC QA checks (in FT0 bins)", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{adaptAnalysisTask(cfgc)}; }