diff --git a/PWGCF/Femto3D/DataModel/PIDutils.h b/PWGCF/Femto3D/DataModel/PIDutils.h new file mode 100644 index 00000000000..9e28f7b5863 --- /dev/null +++ b/PWGCF/Femto3D/DataModel/PIDutils.h @@ -0,0 +1,255 @@ +// 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. + +/// +/// \file PIDutils.h +/// \author Gleb Romanenko gleb.romanenko@cern.ch +/// \brief SFINAE checks for existance of PID info +/// \since 24/03/2025 +/// + +#ifndef PWGCF_FEMTO3D_DATAMODEL_PIDUTILS_H_ +#define PWGCF_FEMTO3D_DATAMODEL_PIDUTILS_H_ + +#include +#include +#include +#include "Common/DataModel/PIDResponse.h" + +namespace o2::aod::singletrackselector +{ +namespace pidutils +{ + +//========================================== SFINAE checks ========================================== + +template +struct hasTPCPi : std::false_type { +}; +template +struct hasTPCPi>> : std::true_type { +}; + +template +struct hasTPCKa : std::false_type { +}; +template +struct hasTPCKa>> : std::true_type { +}; + +template +struct hasTPCPr : std::false_type { +}; +template +struct hasTPCPr>> : std::true_type { +}; + +template +struct hasTPCDe : std::false_type { +}; +template +struct hasTPCDe>> : std::true_type { +}; + +template +struct hasTPCTr : std::false_type { +}; +template +struct hasTPCTr>> : std::true_type { +}; + +template +struct hasTPCHe : std::false_type { +}; +template +struct hasTPCHe>> : std::true_type { +}; + +template +struct hasTOFPi : std::false_type { +}; +template +struct hasTOFPi>> : std::true_type { +}; + +template +struct hasTOFKa : std::false_type { +}; +template +struct hasTOFKa>> : std::true_type { +}; + +template +struct hasTOFPr : std::false_type { +}; +template +struct hasTOFPr>> : std::true_type { +}; + +template +struct hasTOFDe : std::false_type { +}; +template +struct hasTOFDe>> : std::true_type { +}; + +template +struct hasTOFTr : std::false_type { +}; +template +struct hasTOFTr>> : std::true_type { +}; + +template +struct hasTOFHe : std::false_type { +}; +template +struct hasTOFHe>> : std::true_type { +}; + +} // namespace pidutils + +//========================================== ITS PID ========================================== + +template +inline float getITSNsigma(TrackType const& track, int const& PDG) +{ + switch (PDG) { + case 211: + return track.itsNSigmaPi(); + case 321: + return track.itsNSigmaKa(); + case 2212: + return track.itsNSigmaPr(); + case 1000010020: + return track.itsNSigmaDe(); + case 1000020030: + return track.itsNSigmaHe(); + case 1000010030: + return track.itsNSigmaTr(); + case 0: + return -1000.0; + default: + LOG(fatal) << "Cannot interpret PDG for ITS selection: " << PDG; + return -1000.0; + } +} + +template +inline bool ITSselection(TrackType const& track, std::pair> const& PIDcuts) +{ + float Nsigma = getITSNsigma(track, PIDcuts.first); + + if (Nsigma > PIDcuts.second[0] && Nsigma < PIDcuts.second[1]) { + return true; + } + return false; +} + +//========================================== TPC PID ========================================== + +template +inline float getTPCNsigma(TrackType const& track, int const& PDG) +{ + switch (PDG) { + case 211: + if constexpr (o2::aod::singletrackselector::pidutils::hasTPCPi::value) + return track.tpcNSigmaPi(); + case 321: + if constexpr (o2::aod::singletrackselector::pidutils::hasTPCKa::value) + return track.tpcNSigmaKa(); + case 2212: + if constexpr (o2::aod::singletrackselector::pidutils::hasTPCPr::value) + return track.tpcNSigmaPr(); + case 1000010020: + if constexpr (o2::aod::singletrackselector::pidutils::hasTPCDe::value) + return track.tpcNSigmaDe(); + case 1000020030: + if constexpr (o2::aod::singletrackselector::pidutils::hasTPCHe::value) + return track.tpcNSigmaHe(); + case 1000010030: + if constexpr (o2::aod::singletrackselector::pidutils::hasTPCTr::value) + return track.tpcNSigmaTr(); + case 0: + return -1000.0; + default: + LOG(fatal) << "Cannot interpret PDG for TPC selection: " << PDG; + return -1000.0; + } +} + +template +inline bool TPCselection(TrackType const& track, std::pair> const& PIDcuts, std::vector const& ITSCut = std::vector{}) +{ + int PDG = PIDcuts.first; + + if constexpr (useITS) { + if (ITSCut.size() != 0 && !ITSselection(track, std::make_pair(PDG, ITSCut))) + return false; + } + + float Nsigma = getTPCNsigma(track, PDG); + + if (Nsigma > PIDcuts.second[0] && Nsigma < PIDcuts.second[1]) { + return true; + } + return false; +} + +//========================================== TOF PID ========================================== + +template +inline float getTOFNsigma(TrackType const& track, int const& PDG) +{ + switch (PDG) { + case 211: + if constexpr (o2::aod::singletrackselector::pidutils::hasTOFPi::value) + return track.tofNSigmaPi(); + case 321: + if constexpr (o2::aod::singletrackselector::pidutils::hasTOFKa::value) + return track.tofNSigmaKa(); + case 2212: + if constexpr (o2::aod::singletrackselector::pidutils::hasTOFPr::value) + return track.tofNSigmaPr(); + case 1000010020: + if constexpr (o2::aod::singletrackselector::pidutils::hasTOFDe::value) + return track.tofNSigmaDe(); + case 1000020030: + if constexpr (o2::aod::singletrackselector::pidutils::hasTOFHe::value) + return track.tofNSigmaHe(); + case 1000010030: + if constexpr (o2::aod::singletrackselector::pidutils::hasTOFTr::value) + return track.tofNSigmaTr(); + case 0: + return -1000.0; + default: + LOG(fatal) << "Cannot interpret PDG for TOF selection: " << PDG; + return -1000.0; + } +} + +template +inline bool TOFselection(TrackType const& track, std::pair> const& PIDcuts, std::vector const& TPCresidualCut = std::vector{-5.0f, 5.0f}) +{ + int PDG = PIDcuts.first; + if (!TPCselection(track, std::make_pair(PDG, TPCresidualCut))) + return false; + + float Nsigma = getTOFNsigma(track, PDG); + + if (Nsigma > PIDcuts.second[0] && Nsigma < PIDcuts.second[1]) { + return true; + } + return false; +} +} // namespace o2::aod::singletrackselector + +#endif // PWGCF_FEMTO3D_DATAMODEL_PIDUTILS_H_ diff --git a/PWGCF/Femto3D/DataModel/singletrackselector.h b/PWGCF/Femto3D/DataModel/singletrackselector.h index 958c1ecf14c..c7323d15a32 100644 --- a/PWGCF/Femto3D/DataModel/singletrackselector.h +++ b/PWGCF/Femto3D/DataModel/singletrackselector.h @@ -16,7 +16,7 @@ #ifndef PWGCF_FEMTO3D_DATAMODEL_SINGLETRACKSELECTOR_H_ #define PWGCF_FEMTO3D_DATAMODEL_SINGLETRACKSELECTOR_H_ -#include +// #include #include #include @@ -26,6 +26,7 @@ #include "Common/DataModel/PIDResponseITS.h" #include "Framework/Logger.h" #include "Common/DataModel/Multiplicity.h" +#include "PWGCF/Femto3D/DataModel/PIDutils.h" namespace o2::aod { @@ -514,125 +515,3 @@ DECLARE_SOA_TABLE(SingleTrkMCs, "AOD", "SINGLETRKMC", // Table with generatad in } // namespace o2::aod #endif // PWGCF_FEMTO3D_DATAMODEL_SINGLETRACKSELECTOR_H_ - -namespace o2::aod::singletrackselector -{ -template -inline bool ITSselection(TrackType const& track, std::pair> const& PIDcuts) -{ - int PDG = PIDcuts.first; - - float Nsigma = -1000; - switch (PDG) { - case 2212: - Nsigma = track.itsNSigmaPr(); - break; - case 1000010020: - Nsigma = track.itsNSigmaDe(); - break; - case 1000020030: - Nsigma = track.itsNSigmaHe(); - break; - case 1000010030: - Nsigma = track.itsNSigmaTr(); - break; - case 211: - Nsigma = track.itsNSigmaPi(); - break; - case 321: - Nsigma = track.itsNSigmaKa(); - break; - case 0: - return false; - default: - LOG(fatal) << "Cannot interpret PDG for ITS selection: " << PIDcuts.first; - } - - if (Nsigma > PIDcuts.second[0] && Nsigma < PIDcuts.second[1]) { - return true; - } - return false; -} - -template -inline bool TPCselection(TrackType const& track, std::pair> const& PIDcuts, std::vector const& ITSCut = std::vector{}) -{ - int PDG = PIDcuts.first; - - if constexpr (useITS) { - if (ITSCut.size() != 0 && !ITSselection(track, std::make_pair(PDG, ITSCut))) - return false; - } - - float Nsigma = -1000; - switch (PDG) { - case 2212: - Nsigma = track.tpcNSigmaPr(); - break; - case 1000010020: - Nsigma = track.tpcNSigmaDe(); - break; - case 1000020030: - Nsigma = track.tpcNSigmaHe(); - break; - case 1000010030: - Nsigma = track.tpcNSigmaTr(); - break; - case 211: - Nsigma = track.tpcNSigmaPi(); - break; - case 321: - Nsigma = track.tpcNSigmaKa(); - break; - case 0: - return false; - default: - LOG(fatal) << "Cannot interpret PDG for TPC selection: " << PIDcuts.first; - } - - if (Nsigma > PIDcuts.second[0] && Nsigma < PIDcuts.second[1]) { - return true; - } - return false; -} - -template -inline bool TOFselection(TrackType const& track, std::pair> const& PIDcuts, std::vector const& TPCresidualCut = std::vector{-5.0f, 5.0f}) -{ - int PDG = PIDcuts.first; - if (!TPCselection(track, std::make_pair(PDG, TPCresidualCut))) - return false; - - float Nsigma = -1000; - switch (PDG) { - case 2212: - Nsigma = track.tofNSigmaPr(); - break; - case 1000010020: - Nsigma = track.tofNSigmaDe(); - break; - case 1000020030: - Nsigma = track.tofNSigmaHe(); - break; - case 1000010030: - Nsigma = track.tofNSigmaTr(); - break; - case 211: - Nsigma = track.tofNSigmaPi(); - break; - case 321: - Nsigma = track.tofNSigmaKa(); - break; - case 0: - return false; - default: - LOG(fatal) << "Cannot interpret PDG for TOF selection: " << PIDcuts.first; - } - - if (Nsigma > PIDcuts.second[0] && Nsigma < PIDcuts.second[1]) { - return true; - } - return false; -} - -} // namespace o2::aod::singletrackselector diff --git a/PWGCF/Femto3D/Tasks/femto3dPairTask.cxx b/PWGCF/Femto3D/Tasks/femto3dPairTask.cxx index 968ed384c7a..bc91f8a25c2 100644 --- a/PWGCF/Femto3D/Tasks/femto3dPairTask.cxx +++ b/PWGCF/Femto3D/Tasks/femto3dPairTask.cxx @@ -123,7 +123,8 @@ struct FemtoCorrelations { std::pair> TOFcuts_2; using FilteredCollisions = soa::Join; - using FilteredTracks = soa::Join; + // using FilteredTracks = soa::Join; // main + using FilteredTracks = soa::Join; // tmp solution till the HL is fixed typedef std::shared_ptr::iterator> trkType; typedef std::shared_ptr::iterator> colType; @@ -145,6 +146,16 @@ struct FemtoCorrelations { Filter vertexFilter = nabs(o2::aod::singletrackselector::posZ) < _vertexZ; + std::shared_ptr pHisto_first; // momentum histogram for the first particle + std::shared_ptr ITShisto_first; + std::shared_ptr TPChisto_first; + std::shared_ptr TOFhisto_first; + + std::shared_ptr pHisto_second; // momentum histogram for the second particle + std::shared_ptr ITShisto_second; + std::shared_ptr TPChisto_second; + std::shared_ptr TOFhisto_second; + std::vector> MultHistos; std::vector>> kThistos; std::vector>> mThistos; // test @@ -262,13 +273,16 @@ struct FemtoCorrelations { } } - registry.add("p_first", Form("p_%i", static_cast(_particlePDG_1)), kTH1F, {{100, 0., 5., "p"}}); - registry.add("nsigmaTOF_first", Form("nsigmaTOF_%i", static_cast(_particlePDG_1)), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPC_first", Form("nsigmaTPC_%i", static_cast(_particlePDG_1)), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + pHisto_first = registry.add(Form("p_%i", _particlePDG_1.value), Form("p_%i", _particlePDG_1.value), kTH1F, {{100, 0., 5., "p"}}); + ITShisto_first = registry.add(Form("nsigmaITS_PDG%i", _particlePDG_1.value), Form("nsigmaITS_PDG%i", _particlePDG_1.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + TPChisto_first = registry.add(Form("nsigmaTPC_PDG%i", _particlePDG_1.value), Form("nsigmaTPC_PDG%i", _particlePDG_1.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + TOFhisto_first = registry.add(Form("nsigmaTOF_PDG%i", _particlePDG_1.value), Form("nsigmaTOF_PDG%i", _particlePDG_1.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + if (!IsIdentical) { - registry.add("p_second", Form("p_%i", static_cast(_particlePDG_2)), kTH1F, {{100, 0., 5., "p"}}); - registry.add("nsigmaTOF_second", Form("nsigmaTOF_%i", static_cast(_particlePDG_2)), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPC_second", Form("nsigmaTPC_%i", static_cast(_particlePDG_2)), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + pHisto_second = registry.add(Form("p_%i", _particlePDG_2.value), Form("p_%i", _particlePDG_2.value), kTH1F, {{100, 0., 5., "p"}}); + ITShisto_second = registry.add(Form("nsigmaITS_PDG%i", _particlePDG_2.value), Form("nsigmaITS_PDG%i", _particlePDG_2.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + TPChisto_second = registry.add(Form("nsigmaTPC_PDG%i", _particlePDG_2.value), Form("nsigmaTPC_PDG%i", _particlePDG_2.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + TOFhisto_second = registry.add(Form("nsigmaTOF_PDG%i", _particlePDG_2.value), Form("nsigmaTOF_PDG%i", _particlePDG_2.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); } } @@ -395,7 +409,7 @@ struct FemtoCorrelations { if (_particlePDG_1 == 0 || _particlePDG_2 == 0) LOGF(fatal, "One of passed PDG is 0!!!"); - for (auto track : tracks) { + for (const auto& track : tracks) { if (std::fabs(track.template singleCollSel_as>().posZ()) > _vertexZ) continue; if (_removeSameBunchPileup && !track.template singleCollSel_as>().isNoSameBunchPileup()) @@ -420,53 +434,27 @@ struct FemtoCorrelations { continue; if (track.sign() == _sign_1 && (track.p() < _PIDtrshld_1 ? o2::aod::singletrackselector::TPCselection(track, TPCcuts_1, _itsNSigma_1.value) : o2::aod::singletrackselector::TOFselection(track, TOFcuts_1, _tpcNSigmaResidual_1.value))) { // filling the map: eventID <-> selected particles1 - selectedtracks_1[track.singleCollSelId()].push_back(std::make_shared(track)); + selectedtracks_1[track.singleCollSelId()].push_back(std::make_shared::iterator>(track)); - registry.fill(HIST("p_first"), track.p()); - if (_particlePDG_1 == 211) { - registry.fill(HIST("nsigmaTOF_first"), track.p(), track.tofNSigmaPi()); - registry.fill(HIST("nsigmaTPC_first"), track.p(), track.tpcNSigmaPi()); - } - if (_particlePDG_1 == 321) { - registry.fill(HIST("nsigmaTOF_first"), track.p(), track.tofNSigmaKa()); - registry.fill(HIST("nsigmaTPC_first"), track.p(), track.tpcNSigmaKa()); - } - if (_particlePDG_1 == 2212) { - registry.fill(HIST("nsigmaTOF_first"), track.p(), track.tofNSigmaPr()); - registry.fill(HIST("nsigmaTPC_first"), track.p(), track.tpcNSigmaPr()); - } - if (_particlePDG_1 == 1000010020) { - registry.fill(HIST("nsigmaTOF_first"), track.p(), track.tofNSigmaDe()); - registry.fill(HIST("nsigmaTPC_first"), track.p(), track.tpcNSigmaDe()); - } + pHisto_first->Fill(track.p()); + ITShisto_first->Fill(track.p(), o2::aod::singletrackselector::getITSNsigma(track, _particlePDG_1)); + TPChisto_first->Fill(track.p(), o2::aod::singletrackselector::getTPCNsigma(track, _particlePDG_1)); + TOFhisto_first->Fill(track.p(), o2::aod::singletrackselector::getTOFNsigma(track, _particlePDG_1)); } if (IsIdentical) { continue; } else if (track.sign() != _sign_2 && !TOFselection(track, std::make_pair(_particlePDGtoReject, _rejectWithinNsigmaTOF)) && (track.p() < _PIDtrshld_2 ? o2::aod::singletrackselector::TPCselection(track, TPCcuts_2, _itsNSigma_2.value) : o2::aod::singletrackselector::TOFselection(track, TOFcuts_2, _tpcNSigmaResidual_2.value))) { // filling the map: eventID <-> selected particles2 if (see condition above ^) - selectedtracks_2[track.singleCollSelId()].push_back(std::make_shared(track)); + selectedtracks_2[track.singleCollSelId()].push_back(std::make_shared::iterator>(track)); - registry.fill(HIST("p_second"), track.p()); - if (_particlePDG_2 == 211) { - registry.fill(HIST("nsigmaTOF_second"), track.p(), track.tofNSigmaPi()); - registry.fill(HIST("nsigmaTPC_second"), track.p(), track.tpcNSigmaPi()); - } - if (_particlePDG_2 == 321) { - registry.fill(HIST("nsigmaTOF_second"), track.p(), track.tofNSigmaKa()); - registry.fill(HIST("nsigmaTPC_second"), track.p(), track.tpcNSigmaKa()); - } - if (_particlePDG_2 == 2212) { - registry.fill(HIST("nsigmaTOF_second"), track.p(), track.tofNSigmaPr()); - registry.fill(HIST("nsigmaTPC_second"), track.p(), track.tpcNSigmaPr()); - } - if (_particlePDG_2 == 1000010020) { - registry.fill(HIST("nsigmaTOF_second"), track.p(), track.tofNSigmaDe()); - registry.fill(HIST("nsigmaTPC_second"), track.p(), track.tpcNSigmaDe()); - } + pHisto_second->Fill(track.p()); + ITShisto_second->Fill(track.p(), o2::aod::singletrackselector::getITSNsigma(track, _particlePDG_2)); + TPChisto_second->Fill(track.p(), o2::aod::singletrackselector::getTPCNsigma(track, _particlePDG_2)); + TOFhisto_second->Fill(track.p(), o2::aod::singletrackselector::getTOFNsigma(track, _particlePDG_2)); } } - for (auto collision : collisions) { + for (const auto& collision : collisions) { if (collision.multPerc() < *_centBins.value.begin() || collision.multPerc() >= *(_centBins.value.end() - 1)) continue; if (collision.hadronicRate() < _IRcut.value.first || collision.hadronicRate() >= _IRcut.value.second) @@ -494,7 +482,7 @@ struct FemtoCorrelations { int vertexBinToMix = std::floor((collision.posZ() + _vertexZ) / (2 * _vertexZ / _vertexNbinsToMix)); float centBinToMix = o2::aod::singletrackselector::getBinIndex(collision.multPerc(), _centBins, _multNsubBins); - mixbins[std::pair{vertexBinToMix, centBinToMix}].push_back(std::make_shared(collision)); + mixbins[std::pair{vertexBinToMix, centBinToMix}].push_back(std::make_shared::iterator>(collision)); } //====================================== mixing starts here ====================================== diff --git a/PWGCF/Femto3D/Tasks/femto3dQA.cxx b/PWGCF/Femto3D/Tasks/femto3dQA.cxx index 22fab0e58b0..6923ae91cb6 100644 --- a/PWGCF/Femto3D/Tasks/femto3dQA.cxx +++ b/PWGCF/Femto3D/Tasks/femto3dQA.cxx @@ -83,6 +83,10 @@ struct QAHistograms { std::pair> TPCcuts; std::pair> TOFcuts; + std::shared_ptr ITShisto; + std::shared_ptr TPChisto; + std::shared_ptr TOFhisto; + Filter signFilter = o2::aod::singletrackselector::sign == _sign; Filter pFilter = o2::aod::singletrackselector::p > _min_P&& o2::aod::singletrackselector::p < _max_P; Filter etaFilter = nabs(o2::aod::singletrackselector::eta) < _eta; @@ -145,40 +149,9 @@ struct QAHistograms { registry.add("TPCSignal", "TPC Signal", kTH2F, {{{200, 0., 5.0, "#it{p}_{inner} (GeV/#it{c})"}, {1000, 0., 1000.0, "dE/dx in TPC (arbitrary units)"}}}); registry.add("TOFSignal", "TOF Signal", kTH2F, {{200, 0., 5.0, "#it{p} (GeV/#it{c})"}, {100, 0., 1.5, "#beta"}}); - switch (_particlePDG) { - case 211: - registry.add("nsigmaTOFPi", "nsigmaTOFPi", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPCPi", "nsigmaTPCPi", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaITSPi", "nsigmaITSPi", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - break; - case 321: - registry.add("nsigmaTOFKa", "nsigmaTOFKa", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPCKa", "nsigmaTPCKa", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaITSKa", "nsigmaITSKa", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - break; - case 2212: - registry.add("nsigmaTOFPr", "nsigmaTOFPr", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPCPr", "nsigmaTPCPr", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaITSPr", "nsigmaITSPr", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - break; - case 1000010020: - registry.add("nsigmaTOFDe", "nsigmaTOFDe", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPCDe", "nsigmaTPCDe", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaITSDe", "nsigmaITSDe", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - break; - case 1000010030: - registry.add("nsigmaTOFTr", "nsigmaTOFTr", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPCTr", "nsigmaTPCTr", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaITSTr", "nsigmaITSTr", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - break; - case 1000020030: - registry.add("nsigmaTOFHe", "nsigmaTOFHe", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaTPCHe", "nsigmaTPCHe", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - registry.add("nsigmaITSHe", "nsigmaITSHe", kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); - break; - default: - break; - } + ITShisto = registry.add(Form("nsigmaITS_PDG%i", _particlePDG.value), Form("nsigmaITS_PDG%i", _particlePDG.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + TPChisto = registry.add(Form("nsigmaTPC_PDG%i", _particlePDG.value), Form("nsigmaTPC_PDG%i", _particlePDG.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); + TOFhisto = registry.add(Form("nsigmaTOF_PDG%i", _particlePDG.value), Form("nsigmaTOF_PDG%i", _particlePDG.value), kTH2F, {{100, 0., 5.}, {100, -10., 10.}}); const AxisSpec axisMult{5001, -0.5, 5000.5, "mult."}; const AxisSpec axisPerc{101, -0.5, 100.5, "percentile"}; @@ -215,7 +188,7 @@ struct QAHistograms { registry.fill(HIST("IRvsOccupancy"), collision.occupancy(), collision.hadronicRate()); } - for (auto& track : tracks) { + for (const auto& track : tracks) { if (_removeSameBunchPileup && !track.template singleCollSel_as().isNoSameBunchPileup()) continue; @@ -266,40 +239,9 @@ struct QAHistograms { registry.fill(HIST("ITSchi2"), track.itsChi2NCl()); registry.fill(HIST("TPCchi2"), track.tpcChi2NCl()); - switch (_particlePDG) { - case 211: - registry.fill(HIST("nsigmaTOFPi"), track.p(), track.tofNSigmaPi()); - registry.fill(HIST("nsigmaTPCPi"), track.p(), track.tpcNSigmaPi()); - registry.fill(HIST("nsigmaITSPi"), track.p(), track.itsNSigmaPi()); - break; - case 321: - registry.fill(HIST("nsigmaTOFKa"), track.p(), track.tofNSigmaKa()); - registry.fill(HIST("nsigmaTPCKa"), track.p(), track.tpcNSigmaKa()); - registry.fill(HIST("nsigmaITSKa"), track.p(), track.itsNSigmaKa()); - break; - case 2212: - registry.fill(HIST("nsigmaTOFPr"), track.p(), track.tofNSigmaPr()); - registry.fill(HIST("nsigmaTPCPr"), track.p(), track.tpcNSigmaPr()); - registry.fill(HIST("nsigmaITSPr"), track.p(), track.itsNSigmaPr()); - break; - case 1000010020: - registry.fill(HIST("nsigmaTOFDe"), track.p(), track.tofNSigmaDe()); - registry.fill(HIST("nsigmaTPCDe"), track.p(), track.tpcNSigmaDe()); - registry.fill(HIST("nsigmaITSDe"), track.p(), track.itsNSigmaDe()); - break; - case 1000010030: - registry.fill(HIST("nsigmaTOFTr"), track.p(), track.tofNSigmaTr()); - registry.fill(HIST("nsigmaTPCTr"), track.p(), track.tpcNSigmaTr()); - registry.fill(HIST("nsigmaITSTr"), track.p(), track.itsNSigmaTr()); - break; - case 1000020030: - registry.fill(HIST("nsigmaTOFHe"), track.p(), track.tofNSigmaHe()); - registry.fill(HIST("nsigmaTPCHe"), track.p(), track.tpcNSigmaHe()); - registry.fill(HIST("nsigmaITSHe"), track.p(), track.itsNSigmaHe()); - break; - default: - break; - } + ITShisto->Fill(track.p(), o2::aod::singletrackselector::getITSNsigma(track, _particlePDG)); + TPChisto->Fill(track.p(), o2::aod::singletrackselector::getTPCNsigma(track, _particlePDG)); + TOFhisto->Fill(track.p(), o2::aod::singletrackselector::getTOFNsigma(track, _particlePDG)); if constexpr (FillExtra) { registry.fill(HIST("TPCSignal"), track.tpcInnerParam(), track.tpcSignal()); @@ -309,13 +251,15 @@ struct QAHistograms { } } - void processDefault(soa::Filtered> const& collisions, soa::Filtered> const& tracks) + // void processDefault(soa::Filtered> const& collisions, soa::Filtered> const& tracks) // main + void processDefault(soa::Filtered> const& collisions, soa::Filtered> const& tracks) // tmp solution till the HL is fixed { fillHistograms(collisions, tracks); } PROCESS_SWITCH(QAHistograms, processDefault, "process default", true); - void processExtra(soa::Filtered> const& collisions, soa::Filtered> const& tracks) + // void processExtra(soa::Filtered> const& collisions, soa::Filtered> const& tracks) // main + void processExtra(soa::Filtered> const& collisions, soa::Filtered> const& tracks) // tmp solution till the HL is fixed { fillHistograms(collisions, tracks); }