From f730a30d5191879f1e9e4a3476c9802767b0b19f Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 13 Nov 2024 10:15:33 +0100 Subject: [PATCH 01/17] [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 02/17] 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 03/17] 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 04/17] 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 05/17] 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 06/17] 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)}; } From 37147db367cca69a33547177fba07c5261944360 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Wed, 11 Dec 2024 09:01:11 +0100 Subject: [PATCH 07/17] [PWGLF] Removed filters for collisions --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 509 ++++++++++++--------------- 1 file changed, 227 insertions(+), 282 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index a800b3a1002..51239d43989 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". @@ -64,15 +64,9 @@ struct PseudorapidityDensityMFT { // Histogram registry HistogramRegistry registry{ - "registry", - {}, - OutputObjHandlingPolicy::AnalysisObject}; + "registry", {}, 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"}; @@ -88,8 +82,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; @@ -100,62 +94,57 @@ 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, @@ -184,7 +173,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"); @@ -201,7 +190,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}}}}); @@ -244,7 +233,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"); @@ -259,12 +248,12 @@ struct PseudorapidityDensityMFT { {HistType::kTH3F, {PhiAxis, EtaAxis, CentAxis}}}); QAregistry.add({"Events/Centrality/hcentFT0C", " ; cent FT0C", - {HistType::kTH1F, {{1000, 0, 100}}}, + {HistType::kTH1F, {CentAxis}}, 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}}}); @@ -289,9 +278,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}}}); @@ -322,7 +311,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"); @@ -352,7 +341,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) { @@ -360,7 +349,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"); @@ -402,24 +391,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.}}}}); @@ -452,13 +441,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}}}); @@ -492,30 +481,25 @@ 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}}}); } } - /// 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); + (nabs(aod::fwdtrack::bestDCAXY) < trkcuts.cfg_max_dcaxy); /// Filters - mc particles Filter primaries = (aod::mcparticle::flags & @@ -525,7 +509,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; @@ -536,33 +520,12 @@ struct PseudorapidityDensityMFT { 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) - { + 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()) @@ -588,11 +551,10 @@ 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(), @@ -634,12 +596,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 &atrack : besttracks) { auto itrack = atrack.template mfttrack_as(); if (!isTrackSelected(itrack)) { continue; @@ -692,11 +653,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 &particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; } @@ -706,8 +665,7 @@ struct PseudorapidityDensityMFT { } template - bool isGoodEvent(C const& collision) - { + bool isGoodEvent(C const &collision) { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -768,8 +726,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) { @@ -779,10 +736,9 @@ 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; } @@ -822,15 +778,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 &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); @@ -854,9 +809,8 @@ 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(); @@ -878,7 +832,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 { @@ -888,9 +842,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(); @@ -911,8 +864,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 { @@ -921,20 +874,18 @@ 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) - { - processData(collision, tracks); + 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(filtCollsCent::iterator const& collision, - filtMftTracks const& tracks) - { - processData(collision, tracks); + void processDataCent(CollsCent::iterator const &collision, + filtMftTracks const &tracks) { + processData(collision, tracks); } PROCESS_SWITCH(PseudorapidityDensityMFT, processDataCent, @@ -943,10 +894,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) - { - processDatawBestTracks(collision, tracks, besttracks); + Colls::iterator const &collision, filtMftTracks const &tracks, + soa::SmallGroups const &besttracks) { + processDatawBestTracks(collision, tracks, besttracks); } PROCESS_SWITCH(PseudorapidityDensityMFT, processDatawBestTracksInclusive, @@ -955,10 +905,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) - { - processDatawBestTracks(collision, tracks, besttracks); + CollsCent::iterator const &collision, filtMftTracks const &tracks, + soa::SmallGroups const &besttracks) { + processDatawBestTracks(collision, tracks, besttracks); } PROCESS_SWITCH(PseudorapidityDensityMFT, processDatawBestTracksCent, @@ -973,14 +922,13 @@ 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(); @@ -1008,10 +956,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"), @@ -1043,7 +991,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()) { @@ -1077,12 +1025,12 @@ 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) - { - processMC(mccollision, collisions, particles, - tracks); + aod::McCollisions::iterator const &mccollision, + soa::SmallGroups> const + &collisions, + filtParticles const &particles, filtMcMftTracks const &tracks) { + processMC(mccollision, collisions, particles, + tracks); } PROCESS_SWITCH(PseudorapidityDensityMFT, processMCInclusive, @@ -1090,33 +1038,32 @@ 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) - { - processMC(mccollision, collisions, particles, - tracks); + 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; + 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(); @@ -1142,12 +1089,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, @@ -1189,15 +1136,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) - { - processMCwBestTracks( - mccollision, collisions, particles, tracks, 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); } PROCESS_SWITCH(PseudorapidityDensityMFT, processMCwBestTracksInclusive, @@ -1206,13 +1153,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) - { - processMCwBestTracks( - mccollision, collisions, particles, tracks, 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); } PROCESS_SWITCH(PseudorapidityDensityMFT, processMCwBestTracksCent, @@ -1221,19 +1168,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; } @@ -1248,10 +1195,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; } @@ -1269,8 +1216,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; } @@ -1286,9 +1233,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 @@ -1315,9 +1262,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(), @@ -1332,10 +1279,9 @@ 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); } @@ -1346,10 +1292,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); } @@ -1361,12 +1307,11 @@ 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; } @@ -1381,8 +1326,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; } @@ -1396,7 +1341,7 @@ struct PseudorapidityDensityMFT { } } - for (auto const& track : besttracks) { + for (auto const &track : besttracks) { auto itrack = track.mfttrack_as(); if (!isTrackSelected(itrack)) { continue; @@ -1425,56 +1370,58 @@ 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, + aod::McCollisions 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"), - static_cast(collisions.size()) / mcCollisions.size(), c_rec); + QAregistry.fill( + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), c_rec); } else { QAregistry.fill(HIST("Events/hRecPerGenColls"), - static_cast(collisions.size()) / mcCollisions.size()); + static_cast(collisions.size()) / + mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1483,9 +1430,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; @@ -1506,12 +1453,11 @@ 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) - { - processMcQA(collisions, mcCollisions, particles, tracks, - 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); } PROCESS_SWITCH(PseudorapidityDensityMFT, processMcQAInclusive, @@ -1519,19 +1465,18 @@ 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) - { - processMcQA(collisions, mcCollisions, particles, tracks, - 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); } PROCESS_SWITCH(PseudorapidityDensityMFT, processMcQACent, "Process MC QA checks (in FT0 bins)", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ +WorkflowSpec defineDataProcessing(ConfigContext const &cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From ea6a5c61b497bbf1a68cd94ab5dddba77819f7a2 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 11 Dec 2024 08:37:19 +0000 Subject: [PATCH 08/17] Please consider the following formatting changes --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 451 ++++++++++++++------------- 1 file changed, 242 insertions(+), 209 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index 51239d43989..6b3c36c7b75 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -64,9 +64,15 @@ struct PseudorapidityDensityMFT { // Histogram registry HistogramRegistry registry{ - "registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + "registry", + {}, + 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"}; @@ -82,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; @@ -94,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, @@ -173,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"); @@ -190,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}}}}); @@ -233,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"); @@ -251,9 +262,9 @@ struct PseudorapidityDensityMFT { {HistType::kTH1F, {CentAxis}}, 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}}}); @@ -278,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}}}); @@ -311,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"); @@ -341,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) { @@ -349,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"); @@ -391,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.}}}}); @@ -441,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}}}); @@ -481,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}}}); } } @@ -499,7 +510,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 & @@ -509,7 +520,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; @@ -525,7 +536,9 @@ struct PseudorapidityDensityMFT { using filtBestTracks = 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()) @@ -551,10 +564,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(), @@ -596,11 +610,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; @@ -653,9 +668,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; } @@ -665,7 +682,8 @@ struct PseudorapidityDensityMFT { } template - bool isGoodEvent(C const &collision) { + bool isGoodEvent(C const& collision) + { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -726,7 +744,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) { @@ -736,9 +755,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; } @@ -778,14 +798,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); @@ -809,8 +830,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(); @@ -832,7 +854,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 { @@ -842,8 +864,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(); @@ -864,8 +887,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 { @@ -874,8 +897,9 @@ 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) { + void processDataInclusive(Colls::iterator const& collision, + filtMftTracks const& tracks) + { processData(collision, tracks); } @@ -883,8 +907,9 @@ struct PseudorapidityDensityMFT { false); /// @brief process fnc. to run on DATA and REC MC w/ FT0C centrality selection - void processDataCent(CollsCent::iterator const &collision, - filtMftTracks const &tracks) { + void processDataCent(CollsCent::iterator const& collision, + filtMftTracks const& tracks) + { processData(collision, tracks); } @@ -894,8 +919,9 @@ 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); } @@ -905,8 +931,9 @@ 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); } @@ -922,13 +949,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(); @@ -956,10 +984,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"), @@ -991,7 +1019,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()) { @@ -1025,10 +1053,10 @@ struct PseudorapidityDensityMFT { /// @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); } @@ -1038,10 +1066,10 @@ 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); } @@ -1050,20 +1078,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(); @@ -1089,12 +1118,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, @@ -1136,15 +1165,15 @@ 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, @@ -1153,13 +1182,13 @@ 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, @@ -1168,19 +1197,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; } @@ -1195,10 +1224,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; } @@ -1216,8 +1245,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; } @@ -1233,9 +1262,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 @@ -1262,9 +1291,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(), @@ -1279,9 +1308,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); } @@ -1292,10 +1322,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); } @@ -1307,11 +1337,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; } @@ -1326,8 +1357,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; } @@ -1341,7 +1372,7 @@ struct PseudorapidityDensityMFT { } } - for (auto const &track : besttracks) { + for (auto const& track : besttracks) { auto itrack = track.mfttrack_as(); if (!isTrackSelected(itrack)) { continue; @@ -1370,58 +1401,59 @@ 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, - aod::McCollisions const &mcCollisions, - filtParticles const & /*particles*/, MFTTracksLabeled const &tracks, - aod::AmbiguousMFTTracks const &atracks) { - for (const auto &collision : collisions) { + 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; if constexpr (C::template contains()) { c_rec = collision.centFT0C(); QAregistry.fill( - HIST("Events/Centrality/hRecPerGenColls"), - static_cast(collisions.size()) / mcCollisions.size(), c_rec); + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), c_rec); } else { QAregistry.fill(HIST("Events/hRecPerGenColls"), static_cast(collisions.size()) / - mcCollisions.size()); + mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1430,9 +1462,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; @@ -1453,10 +1485,10 @@ struct PseudorapidityDensityMFT { /// @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); } @@ -1465,10 +1497,10 @@ 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); } @@ -1477,6 +1509,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)}; } From 3d33c149dedfb136378dc46e95df2a391a6e56fa Mon Sep 17 00:00:00 2001 From: Gyula Bencedi Date: Wed, 11 Dec 2024 22:03:11 +0100 Subject: [PATCH 09/17] Update dndeta-mft-pbpb.cxx fix copyright header --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index 6b3c36c7b75..913fa96ea94 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 6583630ca6837c4ae75e755f1481e9ad03fa11a9 Mon Sep 17 00:00:00 2001 From: Gyula Bencedi Date: Mon, 13 Jan 2025 15:50:52 +0100 Subject: [PATCH 10/17] [PWGLF] Remove Filter for collisions Remove Filtered collisions for tracking efficiency process functions --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index a220811d105..f4813bd737f 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -1205,7 +1205,7 @@ struct PseudorapidityDensityMFT { /// as particle-to-MFT-tracks) template void processTrkEffIdx( - typename soa::Filtered> const& collisions, + typename soa::Join const& collisions, MC const& /*mccollisions*/, ParticlesI const& /*particles*/, MFTTracksLabeled const& tracks) { @@ -1308,7 +1308,7 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (inclusive, /// indexed) void processTrkEffIdxInlusive( - soa::Filtered> const& collisions, + soa::Join const& collisions, aod::McCollisions const& mccollisions, ParticlesI const& particles, MFTTracksLabeled const& tracks) { @@ -1322,7 +1322,7 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (FT0 bins, /// indexed) void processTrkEffIdxCent( - soa::Filtered> const& collisions, + soa::Join const& collisions, aod::McCollisions const& mccollisions, ParticlesI const& particles, MFTTracksLabeled const& tracks) { @@ -1337,8 +1337,8 @@ struct PseudorapidityDensityMFT { /// on BestCollisionsFwd in FT0C bins template void processTrkEffBest( - typename soa::Filtered< - soa::Join>::iterator const& collision, + typename + soa::Join::iterator const& collision, MC const& /*mccollisions*/, filtParticles const& particles, filtMcMftTracks const& /*tracks*/, soa::SmallGroups const& besttracks) @@ -1401,7 +1401,7 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (inclusive, based /// on BestCollisionsFwd) void processTrkEffBestInclusive( - soa::Filtered>::iterator const& collision, + soa::Join::iterator const& collision, aod::McCollisions const& mccollisions, filtParticles const& particles, filtMcMftTracks const& tracks, soa::SmallGroups const& besttracks) @@ -1418,7 +1418,7 @@ struct PseudorapidityDensityMFT { /// @brief process function to calculate tracking efficiency (in FT0 bins, /// based on BestCollisionsFwd) void processTrkEffBestCent( - soa::Filtered>:: + soa::Join:: iterator const& collision, aod::McCollisions const& mccollisions, filtParticles const& particles, filtMcMftTracks const& tracks, From 8d1c2c3f709bbc70e474560cf16a914aaad0560e Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Mon, 13 Jan 2025 14:53:10 +0000 Subject: [PATCH 11/17] Please consider the following formatting changes --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index f4813bd737f..d5ca119851c 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -1337,8 +1337,7 @@ struct PseudorapidityDensityMFT { /// on BestCollisionsFwd in FT0C bins template void processTrkEffBest( - typename - soa::Join::iterator const& collision, + typename soa::Join::iterator const& collision, MC const& /*mccollisions*/, filtParticles const& particles, filtMcMftTracks const& /*tracks*/, soa::SmallGroups const& besttracks) From 70fe555d26000f5b3042e45c693bfffe991ebd57 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Fri, 17 Jan 2025 19:08:00 +0100 Subject: [PATCH 12/17] [PWGLF] Add azimuthal angle cut --- PWGMM/Mult/Tasks/CMakeLists.txt | 2 +- ...{dndeta-mft-pbpb.cxx => dndetaMFTPbPb.cxx} | 977 +++++++++--------- 2 files changed, 464 insertions(+), 515 deletions(-) rename PWGMM/Mult/Tasks/{dndeta-mft-pbpb.cxx => dndetaMFTPbPb.cxx} (58%) 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/dndetaMFTPbPb.cxx similarity index 58% rename from PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx rename to PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx index d5ca119851c..8946e6683c4 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndetaMFTPbPb.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". @@ -8,15 +8,10 @@ // 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 /// +/// \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)}; } From 39580eb598235fe908d87decaa6122257942866c Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Fri, 17 Jan 2025 19:38:49 +0100 Subject: [PATCH 13/17] fix copyright --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 1464 ++++++++++++++++++++++++++ 1 file changed, 1464 insertions(+) create mode 100644 PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx new file mode 100644 index 00000000000..a776b80c2f2 --- /dev/null +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -0,0 +1,1464 @@ +// 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. +// +// 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)}; +} From 4ca03da8391c1c36a15a5326dfc8b94ef0cc01aa Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Fri, 17 Jan 2025 19:48:55 +0100 Subject: [PATCH 14/17] fix copyright --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index a776b80c2f2..783436990d1 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -8,8 +8,7 @@ // 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 From 7b73184f1c17fb8d26ed6852e28e10a1cc663251 Mon Sep 17 00:00:00 2001 From: Gyula BENCEDI Date: Fri, 17 Jan 2025 19:55:33 +0100 Subject: [PATCH 15/17] . --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index 783436990d1..a0240debe4b 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -8,7 +8,7 @@ // 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 From 2b6307dcfd2c697a23957436f257b97b29b47bed Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 17 Jan 2025 18:56:06 +0000 Subject: [PATCH 16/17] Please consider the following formatting changes --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 386 +++++++++++++++------------ PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx | 386 +++++++++++++++------------ 2 files changed, 428 insertions(+), 344 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index a0240debe4b..9bc57c2c63e 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -59,9 +59,15 @@ struct DndetaMFTPbPb { // Histogram registry HistogramRegistry registry{ - "registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + "registry", + {}, + 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"}; @@ -79,7 +85,7 @@ struct DndetaMFTPbPb { Configurable cfgPtMin{"cfgPtMin", 0., "minimum pT of the MFT tracks"}; Configurable cfgRequireCA{"cfgRequireCA", false, - "Use Cellular Automaton track-finding algorithm"}; + "Use Cellular Automaton track-finding algorithm"}; Configurable cfgDCAxyMax{"cfgDCAxyMax", 2.0f, "Cut on dcaXY"}; } trkcuts; @@ -90,13 +96,13 @@ struct DndetaMFTPbPb { Configurable useZDiffCut{"useZDiffCut", false, "use Zvtx reco-mc diff. cut"}; Configurable maxZvtxDiff{"maxZvtxDiff", 1.0f, - "max allowed Z vtx difference for reconstruced collisions (cm)"}; + "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"}; + "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"}; + "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, @@ -105,36 +111,41 @@ struct DndetaMFTPbPb { 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}, - ""}; + {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, @@ -163,7 +174,7 @@ struct DndetaMFTPbPb { ";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"); @@ -180,7 +191,7 @@ struct DndetaMFTPbPb { "; #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}}}}); @@ -223,7 +234,7 @@ struct DndetaMFTPbPb { ";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"); @@ -241,9 +252,9 @@ struct DndetaMFTPbPb { {HistType::kTH1F, {centAxis}}, 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}}}); @@ -268,9 +279,9 @@ struct DndetaMFTPbPb { "; #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}}}); @@ -301,7 +312,7 @@ struct DndetaMFTPbPb { ";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"); @@ -331,7 +342,7 @@ struct DndetaMFTPbPb { " ; 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) { @@ -339,7 +350,7 @@ struct DndetaMFTPbPb { ";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"); @@ -381,24 +392,24 @@ struct DndetaMFTPbPb { 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.}}}}); @@ -431,13 +442,13 @@ struct DndetaMFTPbPb { 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}}}); @@ -471,16 +482,16 @@ struct DndetaMFTPbPb { 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}}}); } } @@ -498,7 +509,7 @@ struct DndetaMFTPbPb { /// Joined tables using FullBCs = soa::Join; using CollBCs = - soa::Join; + soa::Join; using Colls = soa::Join; using Coll = Colls::iterator; using CollsCent = soa::Join; @@ -514,7 +525,9 @@ struct DndetaMFTPbPb { using FiltBestTracks = soa::Filtered; using FiltParticles = soa::Filtered; - template bool isTrackSelected(const T &track) { + template + bool isTrackSelected(const T& track) + { if (track.eta() < trkcuts.cfgEtaMin || track.eta() > trkcuts.cfgEtaMax) return false; if (trkcuts.cfgRequireCA && !track.isCA()) @@ -535,17 +548,18 @@ struct DndetaMFTPbPb { (phi > o2::constants::math::TwoPI - cfgPhiCut) || ((phi > ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) - - cfgPhiCut) && + cfgPhiCut) && (phi < ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) + - cfgPhiCut))) + 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 const& track : tracks) { @@ -590,8 +604,9 @@ struct DndetaMFTPbPb { } template - int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, - float c, float occ) { + int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, + float c, float occ) + { auto nATrk = 0; if (besttracks.size() > 0) { for (auto const& atrack : besttracks) { @@ -647,7 +662,9 @@ struct DndetaMFTPbPb { return nATrk; } - template int countPart(P const& particles) { + template + int countPart(P const& particles) + { auto nCharged = 0; for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { @@ -659,7 +676,8 @@ struct DndetaMFTPbPb { } template - bool isGoodEvent(C const& collision) { + bool isGoodEvent(C const& collision) + { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -720,7 +738,8 @@ struct DndetaMFTPbPb { /// @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) { @@ -731,7 +750,8 @@ struct DndetaMFTPbPb { template void fillHistMC(P const& particles, float cent, float zvtx, - bool const atLeastOne) { + bool const atLeastOne) + { for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -772,7 +792,8 @@ struct DndetaMFTPbPb { } /// @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 const& bc : bcs) { if ((bc.selection_bit(aod::evsel::kIsBBT0A) && @@ -804,7 +825,8 @@ struct DndetaMFTPbPb { 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(); @@ -826,7 +848,7 @@ struct DndetaMFTPbPb { } 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 { @@ -836,8 +858,9 @@ struct DndetaMFTPbPb { 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(); @@ -858,8 +881,8 @@ struct DndetaMFTPbPb { } 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 { @@ -869,7 +892,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -878,7 +902,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -888,8 +913,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -899,8 +925,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -916,9 +943,10 @@ struct DndetaMFTPbPb { /// @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 cgen = -1; bool atLeastOne = false; int moreThanOne = 0; @@ -950,10 +978,10 @@ struct DndetaMFTPbPb { } auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); + tracks.sliceBy(perCol, collision.globalIndex()); auto nTrkRec = - countTracks(perCollisionSample, z, crec, - collision.trackOccupancyInTimeRange()); + countTracks(perCollisionSample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { qaregistry.fill(HIST("Events/Centrality/ZvtxDiff"), @@ -985,7 +1013,7 @@ struct DndetaMFTPbPb { } 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()) { @@ -1005,7 +1033,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1019,9 +1047,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1031,9 +1060,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1042,16 +1072,17 @@ struct DndetaMFTPbPb { "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 cgen = -1; bool atLeastOne = false; // int moreThanOne = 0; @@ -1081,12 +1112,12 @@ struct DndetaMFTPbPb { } 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, crec, - collision.trackOccupancyInTimeRange()); + perCollisionSample, perCollisionASample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, @@ -1113,7 +1144,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1128,14 +1159,15 @@ struct DndetaMFTPbPb { /// @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, @@ -1144,12 +1176,13 @@ struct DndetaMFTPbPb { /// @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, @@ -1158,17 +1191,18 @@ struct DndetaMFTPbPb { 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) { + typename soa::Join const& collisions, + MC const& /*mccollisions*/, ParticlesI const& /*particles*/, + MFTTracksLabeled const& tracks) + { for (auto const& collision : collisions) { if (!isGoodEvent(collision)) { continue; @@ -1184,7 +1218,7 @@ struct DndetaMFTPbPb { 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 const& particle : particlesPerCol) { @@ -1205,7 +1239,7 @@ struct DndetaMFTPbPb { auto iscounted = false; auto ncnt = 0; auto relatedTracks = - particle.template mfttracks_as(); + particle.template mfttracks_as(); for (auto const& track : relatedTracks) { if (!isTrackSelected(track)) { continue; @@ -1222,9 +1256,9 @@ struct DndetaMFTPbPb { 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); + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); } } else { if (!iscounted) { // primaries @@ -1251,9 +1285,9 @@ struct DndetaMFTPbPb { if (relatedTracks.size() > 1) { if constexpr (C::template contains()) { qaregistry.fill( - HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), crec); + 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(), @@ -1268,9 +1302,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1281,9 +1316,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1295,10 +1331,11 @@ struct DndetaMFTPbPb { /// 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; } @@ -1313,7 +1350,7 @@ struct DndetaMFTPbPb { auto mcCollision = collision.mcCollision(); auto particlesPerCol = particles.sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); for (auto const& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -1357,54 +1394,56 @@ struct DndetaMFTPbPb { /// @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 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 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) { + 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); + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), crec); } else { qaregistry.fill(HIST("Events/hRecPerGenColls"), static_cast(collisions.size()) / - mcCollisions.size()); + mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1436,9 +1475,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1447,9 +1487,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1458,6 +1499,7 @@ struct DndetaMFTPbPb { "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 index 8946e6683c4..9c6c5547955 100644 --- a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx +++ b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx @@ -59,9 +59,15 @@ struct DndetaMFTPbPb { // Histogram registry HistogramRegistry registry{ - "registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + "registry", + {}, + 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"}; @@ -79,7 +85,7 @@ struct DndetaMFTPbPb { Configurable cfgPtMin{"cfgPtMin", 0., "minimum pT of the MFT tracks"}; Configurable cfgRequireCA{"cfgRequireCA", false, - "Use Cellular Automaton track-finding algorithm"}; + "Use Cellular Automaton track-finding algorithm"}; Configurable cfgDCAxyMax{"cfgDCAxyMax", 2.0f, "Cut on dcaXY"}; } trkcuts; @@ -90,13 +96,13 @@ struct DndetaMFTPbPb { Configurable useZDiffCut{"useZDiffCut", false, "use Zvtx reco-mc diff. cut"}; Configurable maxZvtxDiff{"maxZvtxDiff", 1.0f, - "max allowed Z vtx difference for reconstruced collisions (cm)"}; + "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"}; + "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"}; + "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, @@ -105,36 +111,41 @@ struct DndetaMFTPbPb { 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}, - ""}; + {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, @@ -163,7 +174,7 @@ struct DndetaMFTPbPb { ";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"); @@ -180,7 +191,7 @@ struct DndetaMFTPbPb { "; #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}}}}); @@ -223,7 +234,7 @@ struct DndetaMFTPbPb { ";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"); @@ -241,9 +252,9 @@ struct DndetaMFTPbPb { {HistType::kTH1F, {centAxis}}, 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}}}); @@ -268,9 +279,9 @@ struct DndetaMFTPbPb { "; #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}}}); @@ -301,7 +312,7 @@ struct DndetaMFTPbPb { ";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"); @@ -331,7 +342,7 @@ struct DndetaMFTPbPb { " ; 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) { @@ -339,7 +350,7 @@ struct DndetaMFTPbPb { ";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"); @@ -381,24 +392,24 @@ struct DndetaMFTPbPb { 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.}}}}); @@ -431,13 +442,13 @@ struct DndetaMFTPbPb { 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}}}); @@ -471,16 +482,16 @@ struct DndetaMFTPbPb { 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}}}); } } @@ -498,7 +509,7 @@ struct DndetaMFTPbPb { /// Joined tables using FullBCs = soa::Join; using CollBCs = - soa::Join; + soa::Join; using Colls = soa::Join; using Coll = Colls::iterator; using CollsCent = soa::Join; @@ -514,7 +525,9 @@ struct DndetaMFTPbPb { using FiltBestTracks = soa::Filtered; using FiltParticles = soa::Filtered; - template bool isTrackSelected(const T &track) { + template + bool isTrackSelected(const T& track) + { if (track.eta() < trkcuts.cfgEtaMin || track.eta() > trkcuts.cfgEtaMax) return false; if (trkcuts.cfgRequireCA && !track.isCA()) @@ -535,17 +548,18 @@ struct DndetaMFTPbPb { (phi > o2::constants::math::TwoPI - cfgPhiCut) || ((phi > ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) - - cfgPhiCut) && + cfgPhiCut) && (phi < ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) + - cfgPhiCut))) + 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 const& track : tracks) { @@ -590,8 +604,9 @@ struct DndetaMFTPbPb { } template - int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, - float c, float occ) { + int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, + float c, float occ) + { auto nATrk = 0; if (besttracks.size() > 0) { for (auto const& atrack : besttracks) { @@ -647,7 +662,9 @@ struct DndetaMFTPbPb { return nATrk; } - template int countPart(P const& particles) { + template + int countPart(P const& particles) + { auto nCharged = 0; for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { @@ -659,7 +676,8 @@ struct DndetaMFTPbPb { } template - bool isGoodEvent(C const& collision) { + bool isGoodEvent(C const& collision) + { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -720,7 +738,8 @@ struct DndetaMFTPbPb { /// @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) { @@ -731,7 +750,8 @@ struct DndetaMFTPbPb { template void fillHistMC(P const& particles, float cent, float zvtx, - bool const atLeastOne) { + bool const atLeastOne) + { for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -772,7 +792,8 @@ struct DndetaMFTPbPb { } /// @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 const& bc : bcs) { if ((bc.selection_bit(aod::evsel::kIsBBT0A) && @@ -804,7 +825,8 @@ struct DndetaMFTPbPb { 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(); @@ -826,7 +848,7 @@ struct DndetaMFTPbPb { } 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 { @@ -836,8 +858,9 @@ struct DndetaMFTPbPb { 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(); @@ -858,8 +881,8 @@ struct DndetaMFTPbPb { } 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 { @@ -869,7 +892,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -878,7 +902,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -888,8 +913,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -899,8 +925,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -916,9 +943,10 @@ struct DndetaMFTPbPb { /// @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 cgen = -1; bool atLeastOne = false; int moreThanOne = 0; @@ -950,10 +978,10 @@ struct DndetaMFTPbPb { } auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); + tracks.sliceBy(perCol, collision.globalIndex()); auto nTrkRec = - countTracks(perCollisionSample, z, crec, - collision.trackOccupancyInTimeRange()); + countTracks(perCollisionSample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { qaregistry.fill(HIST("Events/Centrality/ZvtxDiff"), @@ -985,7 +1013,7 @@ struct DndetaMFTPbPb { } 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()) { @@ -1005,7 +1033,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1019,9 +1047,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1031,9 +1060,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1042,16 +1072,17 @@ struct DndetaMFTPbPb { "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 cgen = -1; bool atLeastOne = false; // int moreThanOne = 0; @@ -1081,12 +1112,12 @@ struct DndetaMFTPbPb { } 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, crec, - collision.trackOccupancyInTimeRange()); + perCollisionSample, perCollisionASample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, @@ -1113,7 +1144,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1128,14 +1159,15 @@ struct DndetaMFTPbPb { /// @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, @@ -1144,12 +1176,13 @@ struct DndetaMFTPbPb { /// @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, @@ -1158,17 +1191,18 @@ struct DndetaMFTPbPb { 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) { + typename soa::Join const& collisions, + MC const& /*mccollisions*/, ParticlesI const& /*particles*/, + MFTTracksLabeled const& tracks) + { for (auto const& collision : collisions) { if (!isGoodEvent(collision)) { continue; @@ -1184,7 +1218,7 @@ struct DndetaMFTPbPb { 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 const& particle : particlesPerCol) { @@ -1205,7 +1239,7 @@ struct DndetaMFTPbPb { auto iscounted = false; auto ncnt = 0; auto relatedTracks = - particle.template mfttracks_as(); + particle.template mfttracks_as(); for (auto const& track : relatedTracks) { if (!isTrackSelected(track)) { continue; @@ -1222,9 +1256,9 @@ struct DndetaMFTPbPb { 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); + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); } } else { if (!iscounted) { // primaries @@ -1251,9 +1285,9 @@ struct DndetaMFTPbPb { if (relatedTracks.size() > 1) { if constexpr (C::template contains()) { qaregistry.fill( - HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), crec); + 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(), @@ -1268,9 +1302,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1281,9 +1316,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1295,10 +1331,11 @@ struct DndetaMFTPbPb { /// 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; } @@ -1313,7 +1350,7 @@ struct DndetaMFTPbPb { auto mcCollision = collision.mcCollision(); auto particlesPerCol = particles.sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); for (auto const& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -1357,54 +1394,56 @@ struct DndetaMFTPbPb { /// @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 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 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) { + 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); + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), crec); } else { qaregistry.fill(HIST("Events/hRecPerGenColls"), static_cast(collisions.size()) / - mcCollisions.size()); + mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1436,9 +1475,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1447,9 +1487,10 @@ struct DndetaMFTPbPb { /// @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); } @@ -1458,6 +1499,7 @@ struct DndetaMFTPbPb { "Process MC QA checks (in FT0 bins)", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ return WorkflowSpec{adaptAnalysisTask(cfgc)}; } From a1d8c340b9b129d9b42b06f9935c7a8ef5858f27 Mon Sep 17 00:00:00 2001 From: Gyula Bencedi Date: Fri, 17 Jan 2025 20:10:44 +0100 Subject: [PATCH 17/17] Revert "[PWGLF] Please consider the following formatting changes to #9372" --- PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx | 386 ++++++++++++--------------- PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx | 386 ++++++++++++--------------- 2 files changed, 344 insertions(+), 428 deletions(-) diff --git a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx index 9bc57c2c63e..a0240debe4b 100644 --- a/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx +++ b/PWGMM/Mult/Tasks/dndeta-mft-pbpb.cxx @@ -59,15 +59,9 @@ struct DndetaMFTPbPb { // Histogram registry HistogramRegistry registry{ - "registry", - {}, - OutputObjHandlingPolicy::AnalysisObject}; + "registry", {}, 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"}; @@ -85,7 +79,7 @@ struct DndetaMFTPbPb { Configurable cfgPtMin{"cfgPtMin", 0., "minimum pT of the MFT tracks"}; Configurable cfgRequireCA{"cfgRequireCA", false, - "Use Cellular Automaton track-finding algorithm"}; + "Use Cellular Automaton track-finding algorithm"}; Configurable cfgDCAxyMax{"cfgDCAxyMax", 2.0f, "Cut on dcaXY"}; } trkcuts; @@ -96,13 +90,13 @@ struct DndetaMFTPbPb { Configurable useZDiffCut{"useZDiffCut", false, "use Zvtx reco-mc diff. cut"}; Configurable maxZvtxDiff{"maxZvtxDiff", 1.0f, - "max allowed Z vtx difference for reconstruced collisions (cm)"}; + "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"}; + "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"}; + "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, @@ -111,41 +105,36 @@ struct DndetaMFTPbPb { 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}, - ""}; + {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, @@ -174,7 +163,7 @@ struct DndetaMFTPbPb { ";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"); @@ -191,7 +180,7 @@ struct DndetaMFTPbPb { "; #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}}}}); @@ -234,7 +223,7 @@ struct DndetaMFTPbPb { ";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"); @@ -252,9 +241,9 @@ struct DndetaMFTPbPb { {HistType::kTH1F, {centAxis}}, 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}}}); @@ -279,9 +268,9 @@ struct DndetaMFTPbPb { "; #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}}}); @@ -312,7 +301,7 @@ struct DndetaMFTPbPb { ";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"); @@ -342,7 +331,7 @@ struct DndetaMFTPbPb { " ; 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) { @@ -350,7 +339,7 @@ struct DndetaMFTPbPb { ";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"); @@ -392,24 +381,24 @@ struct DndetaMFTPbPb { 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.}}}}); @@ -442,13 +431,13 @@ struct DndetaMFTPbPb { 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}}}); @@ -482,16 +471,16 @@ struct DndetaMFTPbPb { 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}}}); } } @@ -509,7 +498,7 @@ struct DndetaMFTPbPb { /// Joined tables using FullBCs = soa::Join; using CollBCs = - soa::Join; + soa::Join; using Colls = soa::Join; using Coll = Colls::iterator; using CollsCent = soa::Join; @@ -525,9 +514,7 @@ struct DndetaMFTPbPb { using FiltBestTracks = soa::Filtered; using FiltParticles = soa::Filtered; - template - bool isTrackSelected(const T& track) - { + template bool isTrackSelected(const T &track) { if (track.eta() < trkcuts.cfgEtaMin || track.eta() > trkcuts.cfgEtaMax) return false; if (trkcuts.cfgRequireCA && !track.isCA()) @@ -548,18 +535,17 @@ struct DndetaMFTPbPb { (phi > o2::constants::math::TwoPI - cfgPhiCut) || ((phi > ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) - - cfgPhiCut) && + cfgPhiCut) && (phi < ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) + - cfgPhiCut))) + 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 const& track : tracks) { @@ -604,9 +590,8 @@ struct DndetaMFTPbPb { } template - int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, - float c, float occ) - { + int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, + float c, float occ) { auto nATrk = 0; if (besttracks.size() > 0) { for (auto const& atrack : besttracks) { @@ -662,9 +647,7 @@ struct DndetaMFTPbPb { return nATrk; } - template - int countPart(P const& particles) - { + template int countPart(P const& particles) { auto nCharged = 0; for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { @@ -676,8 +659,7 @@ struct DndetaMFTPbPb { } template - bool isGoodEvent(C const& collision) - { + bool isGoodEvent(C const& collision) { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -738,8 +720,7 @@ struct DndetaMFTPbPb { /// @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) { @@ -750,8 +731,7 @@ struct DndetaMFTPbPb { template void fillHistMC(P const& particles, float cent, float zvtx, - bool const atLeastOne) - { + bool const atLeastOne) { for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -792,8 +772,7 @@ struct DndetaMFTPbPb { } /// @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 const& bc : bcs) { if ((bc.selection_bit(aod::evsel::kIsBBT0A) && @@ -825,8 +804,7 @@ struct DndetaMFTPbPb { 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(); @@ -848,7 +826,7 @@ struct DndetaMFTPbPb { } 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 { @@ -858,9 +836,8 @@ struct DndetaMFTPbPb { 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,8 +858,8 @@ struct DndetaMFTPbPb { } 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 { @@ -892,8 +869,7 @@ struct DndetaMFTPbPb { /// @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); } @@ -902,8 +878,7 @@ struct DndetaMFTPbPb { /// @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); } @@ -913,9 +888,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -925,9 +899,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -943,10 +916,9 @@ struct DndetaMFTPbPb { /// @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 cgen = -1; bool atLeastOne = false; int moreThanOne = 0; @@ -978,10 +950,10 @@ struct DndetaMFTPbPb { } auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); + tracks.sliceBy(perCol, collision.globalIndex()); auto nTrkRec = - countTracks(perCollisionSample, z, crec, - collision.trackOccupancyInTimeRange()); + countTracks(perCollisionSample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { qaregistry.fill(HIST("Events/Centrality/ZvtxDiff"), @@ -1013,7 +985,7 @@ struct DndetaMFTPbPb { } 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()) { @@ -1033,7 +1005,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1047,10 +1019,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1060,10 +1031,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1072,17 +1042,16 @@ struct DndetaMFTPbPb { "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 cgen = -1; bool atLeastOne = false; // int moreThanOne = 0; @@ -1112,12 +1081,12 @@ struct DndetaMFTPbPb { } 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, crec, - collision.trackOccupancyInTimeRange()); + perCollisionSample, perCollisionASample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, @@ -1144,7 +1113,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1159,15 +1128,14 @@ struct DndetaMFTPbPb { /// @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, @@ -1176,13 +1144,12 @@ struct DndetaMFTPbPb { /// @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, @@ -1191,18 +1158,17 @@ struct DndetaMFTPbPb { 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) - { + typename soa::Join const& collisions, + MC const& /*mccollisions*/, ParticlesI const& /*particles*/, + MFTTracksLabeled const& tracks) { for (auto const& collision : collisions) { if (!isGoodEvent(collision)) { continue; @@ -1218,7 +1184,7 @@ struct DndetaMFTPbPb { 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 const& particle : particlesPerCol) { @@ -1239,7 +1205,7 @@ struct DndetaMFTPbPb { auto iscounted = false; auto ncnt = 0; auto relatedTracks = - particle.template mfttracks_as(); + particle.template mfttracks_as(); for (auto const& track : relatedTracks) { if (!isTrackSelected(track)) { continue; @@ -1256,9 +1222,9 @@ struct DndetaMFTPbPb { 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); + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); } } else { if (!iscounted) { // primaries @@ -1285,9 +1251,9 @@ struct DndetaMFTPbPb { if (relatedTracks.size() > 1) { if constexpr (C::template contains()) { qaregistry.fill( - HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), crec); + 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(), @@ -1302,10 +1268,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1316,10 +1281,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1331,11 +1295,10 @@ struct DndetaMFTPbPb { /// 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; } @@ -1350,7 +1313,7 @@ struct DndetaMFTPbPb { auto mcCollision = collision.mcCollision(); auto particlesPerCol = particles.sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); for (auto const& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -1394,56 +1357,54 @@ struct DndetaMFTPbPb { /// @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 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 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) - { + 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); + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), crec); } else { qaregistry.fill(HIST("Events/hRecPerGenColls"), static_cast(collisions.size()) / - mcCollisions.size()); + mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1475,10 +1436,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1487,10 +1447,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1499,7 +1458,6 @@ struct DndetaMFTPbPb { "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 index 9c6c5547955..8946e6683c4 100644 --- a/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx +++ b/PWGMM/Mult/Tasks/dndetaMFTPbPb.cxx @@ -59,15 +59,9 @@ struct DndetaMFTPbPb { // Histogram registry HistogramRegistry registry{ - "registry", - {}, - OutputObjHandlingPolicy::AnalysisObject}; + "registry", {}, 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"}; @@ -85,7 +79,7 @@ struct DndetaMFTPbPb { Configurable cfgPtMin{"cfgPtMin", 0., "minimum pT of the MFT tracks"}; Configurable cfgRequireCA{"cfgRequireCA", false, - "Use Cellular Automaton track-finding algorithm"}; + "Use Cellular Automaton track-finding algorithm"}; Configurable cfgDCAxyMax{"cfgDCAxyMax", 2.0f, "Cut on dcaXY"}; } trkcuts; @@ -96,13 +90,13 @@ struct DndetaMFTPbPb { Configurable useZDiffCut{"useZDiffCut", false, "use Zvtx reco-mc diff. cut"}; Configurable maxZvtxDiff{"maxZvtxDiff", 1.0f, - "max allowed Z vtx difference for reconstruced collisions (cm)"}; + "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"}; + "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"}; + "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, @@ -111,41 +105,36 @@ struct DndetaMFTPbPb { 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}, - ""}; + {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, @@ -174,7 +163,7 @@ struct DndetaMFTPbPb { ";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"); @@ -191,7 +180,7 @@ struct DndetaMFTPbPb { "; #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}}}}); @@ -234,7 +223,7 @@ struct DndetaMFTPbPb { ";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"); @@ -252,9 +241,9 @@ struct DndetaMFTPbPb { {HistType::kTH1F, {centAxis}}, 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}}}); @@ -279,9 +268,9 @@ struct DndetaMFTPbPb { "; #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}}}); @@ -312,7 +301,7 @@ struct DndetaMFTPbPb { ";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"); @@ -342,7 +331,7 @@ struct DndetaMFTPbPb { " ; 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) { @@ -350,7 +339,7 @@ struct DndetaMFTPbPb { ";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"); @@ -392,24 +381,24 @@ struct DndetaMFTPbPb { 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.}}}}); @@ -442,13 +431,13 @@ struct DndetaMFTPbPb { 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}}}); @@ -482,16 +471,16 @@ struct DndetaMFTPbPb { 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}}}); } } @@ -509,7 +498,7 @@ struct DndetaMFTPbPb { /// Joined tables using FullBCs = soa::Join; using CollBCs = - soa::Join; + soa::Join; using Colls = soa::Join; using Coll = Colls::iterator; using CollsCent = soa::Join; @@ -525,9 +514,7 @@ struct DndetaMFTPbPb { using FiltBestTracks = soa::Filtered; using FiltParticles = soa::Filtered; - template - bool isTrackSelected(const T& track) - { + template bool isTrackSelected(const T &track) { if (track.eta() < trkcuts.cfgEtaMin || track.eta() > trkcuts.cfgEtaMax) return false; if (trkcuts.cfgRequireCA && !track.isCA()) @@ -548,18 +535,17 @@ struct DndetaMFTPbPb { (phi > o2::constants::math::TwoPI - cfgPhiCut) || ((phi > ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) - - cfgPhiCut) && + cfgPhiCut) && (phi < ((o2::constants::math::PIHalf - 0.1) * o2::constants::math::PI) + - cfgPhiCut))) + 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 const& track : tracks) { @@ -604,9 +590,8 @@ struct DndetaMFTPbPb { } template - int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, - float c, float occ) - { + int countBestTracks(T const& /*tracks*/, B const& besttracks, float z, + float c, float occ) { auto nATrk = 0; if (besttracks.size() > 0) { for (auto const& atrack : besttracks) { @@ -662,9 +647,7 @@ struct DndetaMFTPbPb { return nATrk; } - template - int countPart(P const& particles) - { + template int countPart(P const& particles) { auto nCharged = 0; for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { @@ -676,8 +659,7 @@ struct DndetaMFTPbPb { } template - bool isGoodEvent(C const& collision) - { + bool isGoodEvent(C const& collision) { if constexpr (fillHis) { registry.fill(HIST("hEvtSel"), 0); } @@ -738,8 +720,7 @@ struct DndetaMFTPbPb { /// @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) { @@ -750,8 +731,7 @@ struct DndetaMFTPbPb { template void fillHistMC(P const& particles, float cent, float zvtx, - bool const atLeastOne) - { + bool const atLeastOne) { for (auto const& particle : particles) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -792,8 +772,7 @@ struct DndetaMFTPbPb { } /// @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 const& bc : bcs) { if ((bc.selection_bit(aod::evsel::kIsBBT0A) && @@ -825,8 +804,7 @@ struct DndetaMFTPbPb { 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(); @@ -848,7 +826,7 @@ struct DndetaMFTPbPb { } 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 { @@ -858,9 +836,8 @@ struct DndetaMFTPbPb { 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,8 +858,8 @@ struct DndetaMFTPbPb { } 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 { @@ -892,8 +869,7 @@ struct DndetaMFTPbPb { /// @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); } @@ -902,8 +878,7 @@ struct DndetaMFTPbPb { /// @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); } @@ -913,9 +888,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -925,9 +899,8 @@ struct DndetaMFTPbPb { /// @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); } @@ -943,10 +916,9 @@ struct DndetaMFTPbPb { /// @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 cgen = -1; bool atLeastOne = false; int moreThanOne = 0; @@ -978,10 +950,10 @@ struct DndetaMFTPbPb { } auto perCollisionSample = - tracks.sliceBy(perCol, collision.globalIndex()); + tracks.sliceBy(perCol, collision.globalIndex()); auto nTrkRec = - countTracks(perCollisionSample, z, crec, - collision.trackOccupancyInTimeRange()); + countTracks(perCollisionSample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { qaregistry.fill(HIST("Events/Centrality/ZvtxDiff"), @@ -1013,7 +985,7 @@ struct DndetaMFTPbPb { } 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()) { @@ -1033,7 +1005,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1047,10 +1019,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1060,10 +1031,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1072,17 +1042,16 @@ struct DndetaMFTPbPb { "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 cgen = -1; bool atLeastOne = false; // int moreThanOne = 0; @@ -1112,12 +1081,12 @@ struct DndetaMFTPbPb { } 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, crec, - collision.trackOccupancyInTimeRange()); + perCollisionSample, perCollisionASample, z, crec, + collision.trackOccupancyInTimeRange()); if constexpr (C::template contains()) { registry.fill(HIST("Events/Centrality/NtrkZvtxGen"), nTrkRec, z, @@ -1144,7 +1113,7 @@ struct DndetaMFTPbPb { } fillHistMC()>(particles, cgen, - zvtxMC, atLeastOne); + zvtxMC, atLeastOne); if (collisions.size() == 0) { if constexpr (C::template contains()) { @@ -1159,15 +1128,14 @@ struct DndetaMFTPbPb { /// @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, @@ -1176,13 +1144,12 @@ struct DndetaMFTPbPb { /// @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, @@ -1191,18 +1158,17 @@ struct DndetaMFTPbPb { 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) - { + typename soa::Join const& collisions, + MC const& /*mccollisions*/, ParticlesI const& /*particles*/, + MFTTracksLabeled const& tracks) { for (auto const& collision : collisions) { if (!isGoodEvent(collision)) { continue; @@ -1218,7 +1184,7 @@ struct DndetaMFTPbPb { 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 const& particle : particlesPerCol) { @@ -1239,7 +1205,7 @@ struct DndetaMFTPbPb { auto iscounted = false; auto ncnt = 0; auto relatedTracks = - particle.template mfttracks_as(); + particle.template mfttracks_as(); for (auto const& track : relatedTracks) { if (!isTrackSelected(track)) { continue; @@ -1256,9 +1222,9 @@ struct DndetaMFTPbPb { 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); + HIST("Tracks/Centrality/hPtPhiEtaZvtxEffDuplicates"), + particle.pt(), particle.phi(), particle.eta(), + mcCollision.posZ(), crec); } } else { if (!iscounted) { // primaries @@ -1285,9 +1251,9 @@ struct DndetaMFTPbPb { if (relatedTracks.size() > 1) { if constexpr (C::template contains()) { qaregistry.fill( - HIST("Tracks/Centrality/hPtPhiEtaZvtxEffGenDuplicates"), - particle.pt(), particle.phi(), particle.eta(), - mcCollision.posZ(), crec); + 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(), @@ -1302,10 +1268,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1316,10 +1281,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1331,11 +1295,10 @@ struct DndetaMFTPbPb { /// 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; } @@ -1350,7 +1313,7 @@ struct DndetaMFTPbPb { auto mcCollision = collision.mcCollision(); auto particlesPerCol = particles.sliceByCached( - aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); + aod::mcparticle::mcCollisionId, mcCollision.globalIndex(), cache); for (auto const& particle : particlesPerCol) { if (!isChrgParticle(particle.pdgCode())) { continue; @@ -1394,56 +1357,54 @@ struct DndetaMFTPbPb { /// @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 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 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) - { + 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); + HIST("Events/Centrality/hRecPerGenColls"), + static_cast(collisions.size()) / mcCollisions.size(), crec); } else { qaregistry.fill(HIST("Events/hRecPerGenColls"), static_cast(collisions.size()) / - mcCollisions.size()); + mcCollisions.size()); } if (!isGoodEvent(collision)) { @@ -1475,10 +1436,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1487,10 +1447,9 @@ struct DndetaMFTPbPb { /// @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); } @@ -1499,7 +1458,6 @@ struct DndetaMFTPbPb { "Process MC QA checks (in FT0 bins)", false); }; -WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) -{ +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { return WorkflowSpec{adaptAnalysisTask(cfgc)}; }