From f683c5eff6ef982840aebb168526214c0dabafa5 Mon Sep 17 00:00:00 2001 From: mattia Date: Thu, 4 Sep 2025 10:34:51 +0200 Subject: [PATCH 1/3] Tree creator for Sigmac correlated bkg. sources. --- PWGHF/D2H/Tasks/taskSigmac.cxx | 26 +- PWGHF/D2H/Utils/utilsSigmac.h | 47 +++ PWGHF/TableProducer/CMakeLists.txt | 5 + .../treeCreatorSigmacCorrBkg.cxx | 302 ++++++++++++++++++ 4 files changed, 357 insertions(+), 23 deletions(-) create mode 100644 PWGHF/D2H/Utils/utilsSigmac.h create mode 100644 PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx diff --git a/PWGHF/D2H/Tasks/taskSigmac.cxx b/PWGHF/D2H/Tasks/taskSigmac.cxx index b14d0640c88..ed127cd0394 100644 --- a/PWGHF/D2H/Tasks/taskSigmac.cxx +++ b/PWGHF/D2H/Tasks/taskSigmac.cxx @@ -17,6 +17,7 @@ #include "PWGHF/Core/DecayChannels.h" #include "PWGHF/Core/HfHelper.h" +#include "PWGHF/D2H/Utils/utilsSigmac.h" #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" @@ -340,27 +341,6 @@ struct HfTaskSigmac { }; /// end init - /// @brief Function to determine if the reconstructed candidate Σc0,++ decays into Λc+ → pK-π+, Λc+ → π+K-p or both - /// @tparam L template for Lc daughter of Sc candidate - /// @tparam S template for Sc candidate - /// @param candidateLc Lc daughter of Sc candidate - /// @param candSc Sc candidate - /// @return 0: none; 1: only Λc+ → pK-π+ possible; 2: Λc+ → π+K-p possible; 3: both possible - template - int8_t isDecayToPKPiToPiKP(L& candidateLc, S& candSc) - { - int8_t channel = 0; - if ((candidateLc.isSelLcToPKPi() >= 1) && candSc.statusSpreadLcMinvPKPiFromPDG()) { - // Λc+ → pK-π+ and within the requested mass to build the Σc0,++ - SETBIT(channel, o2::aod::hf_cand_sigmac::Decays::PKPi); - } - if ((candidateLc.isSelLcToPiKP() >= 1) && candSc.statusSpreadLcMinvPiKPFromPDG()) { - // Λc+ → π+K-p and within the requested mass to build the Σc0,++ - SETBIT(channel, o2::aod::hf_cand_sigmac::Decays::PiKP); - } - return channel; /// 0: none; 1: pK-π+ only; 2: π+K-p only; 3: both possible - } - /// @brief function to fill the histograms needed in analysis (data) /// @param candidatesSc are the reconstructed candidate Σc0,++ /// @param @@ -386,7 +366,7 @@ struct HfTaskSigmac { const auto& candidateLc = candSc.prongLc_as(); // const int iscandidateLcpKpi = (candidateLc.isSelLcToPKPi() >= 1) && candSc.statusSpreadLcMinvPKPiFromPDG(); // Λc+ → pK-π+ and within the requested mass to build the Σc0,++ // const int iscandidateLcpiKp = (candidateLc.isSelLcToPiKP() >= 1) && candSc.statusSpreadLcMinvPiKPFromPDG(); // Λc+ → π+K-p and within the requested mass to build the Σc0,++ - const int8_t isCandPKPiPiKP = isDecayToPKPiToPiKP(candidateLc, candSc); + const int8_t isCandPKPiPiKP = hf_sigmac_utils::isDecayToPKPiToPiKP(candidateLc, candSc); double massSc(-1.), massLc(-1.), deltaMass(-1.); double ptSc(candSc.pt()), ptLc(candidateLc.pt()); double etaSc(candSc.eta()), etaLc(candidateLc.eta()); @@ -822,7 +802,7 @@ struct HfTaskSigmac { /// get the candidate Λc+ used to build the Σc0 /// and understand which mass hypotheses are possible const auto& candidateLc = candSc.prongLc_as(); - const int8_t isCandPKPiPiKP = isDecayToPKPiToPiKP(candidateLc, candSc); + const int8_t isCandPKPiPiKP = hf_sigmac_utils::isDecayToPKPiToPiKP(candidateLc, candSc); // candidateLc.flagMcDecayChanRec(); diff --git a/PWGHF/D2H/Utils/utilsSigmac.h b/PWGHF/D2H/Utils/utilsSigmac.h new file mode 100644 index 00000000000..b1f9012c28f --- /dev/null +++ b/PWGHF/D2H/Utils/utilsSigmac.h @@ -0,0 +1,47 @@ +// 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 utilsSigmac.h +/// \brief Utilities for Sigmac analysis +/// \author Mattia Faggin , INFN Padova + +#ifndef PWGHF_D2H_UTILS_UTILSSIGMAC_H_ +#define PWGHF_D2H_UTILS_UTILSSIGMAC_H_ + +#include "PWGHF/DataModel/CandidateReconstructionTables.h" + +#include + +namespace o2::hf_sigmac_utils +{ +/// @brief Function to determine if the reconstructed candidate Σc0,++ decays into Λc+ → pK-π+, Λc+ → π+K-p or both +/// @tparam L template for Lc daughter of Sc candidate +/// @tparam S template for Sc candidate +/// @param candidateLc Lc daughter of Sc candidate +/// @param candSc Sc candidate +/// @return 0: none; 1: only Λc+ → pK-π+ possible; 2: Λc+ → π+K-p possible; 3: both possible +template +int8_t isDecayToPKPiToPiKP(L& candidateLc, S& candSc) +{ + int8_t channel = 0; + if ((candidateLc.isSelLcToPKPi() >= 1) && candSc.statusSpreadLcMinvPKPiFromPDG()) { + // Λc+ → pK-π+ and within the requested mass to build the Σc0,++ + SETBIT(channel, o2::aod::hf_cand_sigmac::Decays::PKPi); + } + if ((candidateLc.isSelLcToPiKP() >= 1) && candSc.statusSpreadLcMinvPiKPFromPDG()) { + // Λc+ → π+K-p and within the requested mass to build the Σc0,++ + SETBIT(channel, o2::aod::hf_cand_sigmac::Decays::PiKP); + } + return channel; /// 0: none; 1: pK-π+ only; 2: π+K-p only; 3: both possible +} +} // namespace o2::hf_sigmac_utils + +#endif // PWGHF_D2H_UTILS_UTILSSIGMAC_H_ diff --git a/PWGHF/TableProducer/CMakeLists.txt b/PWGHF/TableProducer/CMakeLists.txt index e57147f6cfc..9b28ce9e88d 100644 --- a/PWGHF/TableProducer/CMakeLists.txt +++ b/PWGHF/TableProducer/CMakeLists.txt @@ -249,6 +249,11 @@ o2physics_add_dpl_workflow(tree-creator-lc-to-p-k-pi PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(tree-creator-sigmac-corr-bkg + SOURCES treeCreatorSigmacCorrBkg.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(tree-creator-omegac-st SOURCES treeCreatorOmegacSt.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2::DCAFitter O2Physics::EventFilteringUtils diff --git a/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx b/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx new file mode 100644 index 00000000000..98939718cb2 --- /dev/null +++ b/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx @@ -0,0 +1,302 @@ +// 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 treeCreatorSigmacCorrBkg.cxx +/// \brief Code to reconstruct correlated-background candidates for Σc0,++ analysis +/// \note Λc± candidates selected from the HFLcCandidateSelector.cxx +/// \note Σc0,++ candidates selected from the candidateCreatorSigmac0plusplus.cxx +/// +/// \author Mattia Faggin , INFN PADOVA + +#include "PWGHF/Core/DecayChannels.h" +#include "PWGHF/Core/HfHelper.h" +#include "PWGHF/D2H/Utils/utilsSigmac.h" +#include "PWGHF/DataModel/CandidateSelectionTables.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace o2; +using namespace o2::framework; // for Produces, Configuable + +namespace o2::aod +{ +namespace hf_sigmac_bkg +{ +const int pdgCodeLambdac2595 = 14122; +const int pdgCodeLambdac2625 = 4124; +enum Decays { Sigmac2455Pi = 0, + LambdacPiPi }; +enum DecaysLambdac { PKPi = 0, + PiKP }; +DECLARE_SOA_COLUMN(Y, y, float); +DECLARE_SOA_COLUMN(Pt, pt, float); +DECLARE_SOA_COLUMN(Mass, mass, float); +DECLARE_SOA_COLUMN(DeltaMass, deltaMass, float); +DECLARE_SOA_COLUMN(Charge, charge, int8_t); +DECLARE_SOA_COLUMN(MotherPdg, motherPdg, int); +DECLARE_SOA_COLUMN(Decay, decay, int8_t); +DECLARE_SOA_COLUMN(DecayLambdac, decayLambdac, int8_t); +DECLARE_SOA_COLUMN(MlScoreFirstClass, mlScoreFirstClass, float); /// background score Λc +DECLARE_SOA_COLUMN(MlScoreThirdClass, mlScoreThirdClass, float); /// non-prompt score Λc +} // namespace hf_sigmac_bkg +DECLARE_SOA_TABLE(HfCorrBkgSc, "AOD", "HFCORRBKGSC", + hf_sigmac_bkg::Y, + hf_sigmac_bkg::Pt, + hf_sigmac_bkg::Mass, + hf_sigmac_bkg::DeltaMass, + hf_sigmac_bkg::Charge, + hf_sigmac_bkg::MotherPdg, + hf_sigmac_bkg::Decay, + hf_sigmac_bkg::DecayLambdac, + hf_sigmac_bkg::MlScoreFirstClass, + hf_sigmac_bkg::MlScoreThirdClass); +} // namespace o2::aod + +struct HfTreeCreatorSigmacCorrBkg { + + Produces rowCorrBkgSc; + + /// Selection of candidates Λc+ + Configurable selectionFlagLc{"selectionFlagLc", 1, "Selection Flag for Lc"}; + Configurable yCandRecoMax{"yCandRecoMax", -1, "Maximum Sc candidate rapidity"}; + + using RecoLcMc = soa::Join; + using RecoScMc = soa::Join; + using ParticlesLcSigmac = soa::Join; + + HfHelper hfHelper; + + /// @brief init function + void init(InitContext&) {} + + /// + void fillTable(RecoScMc::iterator candidateSc, RecoLcMc::iterator candLcDauSc, int motherPdg, int motherDecay = -1) + { + const int8_t chargeSc = candidateSc.charge(); // either Σc0 or Σc++ + const float rapidity = chargeSc == 0 ? hfHelper.ySc0(candidateSc) : hfHelper.yScPlusPlus(candidateSc); // NB: since in data we cannot tag Sc(2455) and Sc(2520), then we use only Sc(2455) for y selection on reconstructed signal + float massSc = -1.f; + float massLc = -1.f; + float deltaMass = -1.f; + const int8_t isCandPKPiPiKP = hf_sigmac_utils::isDecayToPKPiToPiKP(candLcDauSc, candidateSc); + std::array outputMl{-1., -1.}; + /// rapidity selection on Σc0,++ + if (yCandRecoMax >= 0. && std::abs(rapidity) > yCandRecoMax) { + return; + } + + /// BDT scores + if (candLcDauSc.mlProbLcToPiKP().size() > 0) { + outputMl.at(0) = candLcDauSc.mlProbLcToPiKP()[0]; /// bkg score + outputMl.at(1) = candLcDauSc.mlProbLcToPiKP()[2]; /// non-prompt score + } + + if ((TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PKPi)) && std::abs(candLcDauSc.template prong0_as().template mcParticle_as().pdgCode()) == kProton) { + massSc = hfHelper.invMassScRecoLcToPKPi(candidateSc, candLcDauSc); + massLc = hfHelper.invMassLcToPKPi(candLcDauSc); + deltaMass = massSc - massLc; + + /// fill the tree + rowCorrBkgSc(rapidity, candidateSc.pt(), massSc, deltaMass, chargeSc, motherPdg, motherDecay, aod::hf_sigmac_bkg::DecaysLambdac::PKPi, outputMl.at(0), outputMl.at(1)); + } + if ((TESTBIT(isCandPKPiPiKP, o2::aod::hf_cand_sigmac::Decays::PiKP)) && std::abs(candLcDauSc.template prong0_as().template mcParticle_as().pdgCode()) == kPiPlus) { + massSc = hfHelper.invMassScRecoLcToPiKP(candidateSc, candLcDauSc); + massLc = hfHelper.invMassLcToPiKP(candLcDauSc); + deltaMass = massSc - massLc; + + /// fill the tree + rowCorrBkgSc(rapidity, candidateSc.pt(), massSc, deltaMass, chargeSc, motherPdg, motherDecay, aod::hf_sigmac_bkg::DecaysLambdac::PiKP, outputMl.at(0), outputMl.at(1)); + } + } + + /// @brief process function to loop over the Σc reconstructed candidates and match them to corr. background sources in MC + void process(RecoScMc const& candidatesSc, + ParticlesLcSigmac const& particles, + RecoLcMc const&, + aod::TracksWMc const&) + { + /// loop over reconstructed Σc candidates + for (auto& candidateSc : candidatesSc) { + + auto candLcDauSc = candidateSc.template prongLc_as(); + auto candSoftPiDauSc = candidateSc.template prong1_as(); + + /// tag immediately the Σc0,++(2455) and Σc0,++(2520) signal + auto flagMcDecayChanScAbs = std::abs(candidateSc.flagMcMatchRec()); + bool isTrueSigmac0 = (flagMcDecayChanScAbs == BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi)); + bool isTrueSigmacPlusPlus = (flagMcDecayChanScAbs == BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi)); + bool isTrueSigmacStar0 = (flagMcDecayChanScAbs == BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi)); + bool isTrueSigmacStarPlusPlus = (flagMcDecayChanScAbs == BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi)); + if (isTrueSigmac0) { + /// fill the output for the signal + fillTable(candidateSc, candLcDauSc, o2::constants::physics::Pdg::kSigmaC0); + + /// the candidate that we reconstructed is a real Sigmac(2455, 2520), but later we look for correlated background sources + /// let's continue + continue; + } else if (isTrueSigmacPlusPlus) { + /// fill the output for the signal + fillTable(candidateSc, candLcDauSc, o2::constants::physics::Pdg::kSigmaCPlusPlus); + + /// the candidate that we reconstructed is a real Sigmac(2455, 2520), but later we look for correlated background sources + /// let's continue + continue; + } else if (isTrueSigmacStar0) { + /// fill the output for the signal + fillTable(candidateSc, candLcDauSc, o2::constants::physics::Pdg::kSigmaCStar0); + + /// the candidate that we reconstructed is a real Sigmac(2455, 2520), but later we look for correlated background sources + /// let's continue + continue; + } else if (isTrueSigmacStarPlusPlus) { + /// fill the output for the signal + fillTable(candidateSc, candLcDauSc, o2::constants::physics::Pdg::kSigmaCStarPlusPlus); + + /// the candidate that we reconstructed is a real Sigmac(2455, 2520), but later we look for correlated background sources + /// let's continue + continue; + } + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /// /// + /// Look for the Σc0,++ correlated background sources. /// + /// /// + /// Two sources are possible: /// + /// /// + /// 1) Λc±(2595, 2625) → Σc0,++(2455) π+,- /// + /// In this case, we need that the candidate Σc0,++(2455) is formed by the Λc± daughter of a real Σc0,++(2455) /// + /// paired with the bachelor pion of the Λc±(2595, 2625) /// + /// /// + /// 2) Λc±(2595, 2625) → Λc± π+ π- /// + /// It means that the reconstructed Σc candidate it's actually the pair of Λc± π+ or Λc± π- /// + /// coming from the same Λc±(2595) or Λc±(2625) /// + /// /// + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + /// check if the candidate Lc and soft pion daugthers are not real Lc or pion + bool isLambdac = std::abs(candLcDauSc.flagMcMatchRec()) == hf_decay::hf_cand_3prong::DecayChannelMain::LcToPKPi; + bool isPion = false; + if (candSoftPiDauSc.has_mcParticle()) { + isPion = std::abs(candSoftPiDauSc.template mcParticle_as().pdgCode()) == kPiPlus; + } + if (!isLambdac || !isPion) { + continue; + } + + /// First of all, search for an incomplete decay of Λc±(2595, 2625) into Λc± (→ pK-π+) π+ π-, + /// we will distinguish the two background sources from the first mother of the Λc± + /// This means that we look for cases in which we use 4 tracks out of 5, missing one pion. + /// The possible combinations are: (1) pK-π+ π+; (2) pK-π+ π- + /// The full chain has a max depth of 4: + /// i. Λc±(2595, 2625) → Σc0,++(2455) π+,- (+1) + /// ii. Σc0,++(2455) → Λc+ π-,+ (+1) + /// ii. Λc+ → pK-π+ which can go in the direct channel direct (+1) or through a resonance (+2) + auto arrayDaughters = std::array{candLcDauSc.template prong0_as(), + candLcDauSc.template prong1_as(), + candLcDauSc.template prong2_as(), + candidateSc.template prong1_as()}; + auto arrayPdgDaughters1 = std::array{+kProton, -kKPlus, +kPiPlus, +kPiPlus}; /// (1) + auto arrayPdgDaughters2 = std::array{+kProton, -kKPlus, +kPiPlus, -kPiPlus}; /// (2) + int8_t sign = 0; + int indexMother = -1; + int motherPdg = -1; + int motherDecay = -1; + // look for Λc±(2595) - first daughter pdg-code combination + indexMother = RecoDecay::getMatchedMCRec(particles, arrayDaughters, aod::hf_sigmac_bkg::pdgCodeLambdac2595, arrayPdgDaughters1, true, &sign, 4 /*depthMainMax*/); + if (indexMother >= 0) { + /// mother found! + motherPdg = aod::hf_sigmac_bkg::pdgCodeLambdac2595; + } else { + // look for Λc±(2595) - second daughter pdg-code combination + indexMother = RecoDecay::getMatchedMCRec(particles, arrayDaughters, aod::hf_sigmac_bkg::pdgCodeLambdac2595, arrayPdgDaughters2, true, &sign, 4 /*depthMainMax*/); + if (indexMother >= 0) { + /// mother found! + motherPdg = aod::hf_sigmac_bkg::pdgCodeLambdac2595; + } else { + // look for Λc±(2625) - first daughter pdg-code combination + indexMother = RecoDecay::getMatchedMCRec(particles, arrayDaughters, aod::hf_sigmac_bkg::pdgCodeLambdac2625, arrayPdgDaughters1, true, &sign, 4 /*depthMainMax*/); + if (indexMother >= 0) { + /// mother found! + motherPdg = aod::hf_sigmac_bkg::pdgCodeLambdac2625; + } else { + // look for Λc±(2625) - second daughter pdg-code combination + indexMother = RecoDecay::getMatchedMCRec(particles, arrayDaughters, aod::hf_sigmac_bkg::pdgCodeLambdac2625, arrayPdgDaughters2, true, &sign, 4 /*depthMainMax*/); + if (indexMother >= 0) { + /// mother found! + motherPdg = aod::hf_sigmac_bkg::pdgCodeLambdac2625; + } else { + /// no mother found, it means that this is not a corr. bkg candidate + /// let's skip it + continue; + } + } + } + } + // LOG(info) << "motherPdg: " << motherPdg; + + /// now that we matched a Λc±(2595, 2625), let's determine the precise decay channel + /// by checking the mother of the Λc± + auto arrayDaughtersLambdac = std::array{candLcDauSc.template prong0_as(), + candLcDauSc.template prong1_as(), + candLcDauSc.template prong2_as()}; + int8_t signLambdac = 0; + int indexRecLc = RecoDecay::getMatchedMCRec(particles, arrayDaughtersLambdac, o2::constants::physics::Pdg::kLambdaCPlus, std::array{+kProton, -kKPlus, +kPiPlus}, true, &signLambdac, 2); + if (indexRecLc < 0) { + /// this should never happen, since we check above that the isLambdac==true + LOG(fatal) << "Generated Lambdac not found. Not expected. Aborting."; + } + auto particleLc = particles.rawIteratorAt(indexRecLc); + if (particleLc.has_mothers()) { + /// we should always enter here, since the Λc± is coming from a Λc±(2595, 2625) decay + for (auto iMother = particleLc.mothersIds().front(); iMother <= particleLc.mothersIds().back(); ++iMother) { + auto mother = particles.rawIteratorAt(iMother); + int pdgCodeMotherAbs = std::abs(mother.pdgCode()); + if (pdgCodeMotherAbs == o2::constants::physics::Pdg::kSigmaC0 || pdgCodeMotherAbs == o2::constants::physics::Pdg::kSigmaCPlusPlus) { + /// the Λc± comes from a Σc0,++(2455) + /// ==> we found a Λc±(2595, 2625) → Σc0,++(2455) π+,- decay! + motherDecay = aod::hf_sigmac_bkg::Decays::Sigmac2455Pi; + + /// This should be enough, i.e. not necessary to check that the pion is not daughter of the same Sigmac + /// This case should be already excluded by searching for real Sigmac (see the beginning of the process function) + + } else { + /// considering all the checks done before, the only other possibility is that this Λc± directly comes from a Λc±(2595, 2625) + motherDecay = aod::hf_sigmac_bkg::Decays::LambdacPiPi; + } + break; + } + } else { + /// we should never eneter here + LOG(fatal) << "Lambdac particle without mothers. Not expected. Aborting."; + } + + /// we found a corr. bkg. candidate + /// let's fill our output + fillTable(candidateSc, candLcDauSc, motherPdg, motherDecay); + + } /// end loop over reconstructed Σc candidates + } +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From e4556444b0875afa53afcb11ad1327562389262f Mon Sep 17 00:00:00 2001 From: mattia Date: Thu, 4 Sep 2025 10:45:35 +0200 Subject: [PATCH 2/3] Try to address some O2 linter errors. --- PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx b/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx index 98939718cb2..ccb44a33a26 100644 --- a/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx +++ b/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx @@ -79,12 +79,12 @@ struct HfTreeCreatorSigmacCorrBkg { Configurable selectionFlagLc{"selectionFlagLc", 1, "Selection Flag for Lc"}; Configurable yCandRecoMax{"yCandRecoMax", -1, "Maximum Sc candidate rapidity"}; + HfHelper hfHelper; + using RecoLcMc = soa::Join; using RecoScMc = soa::Join; using ParticlesLcSigmac = soa::Join; - HfHelper hfHelper; - /// @brief init function void init(InitContext&) {} @@ -134,7 +134,7 @@ struct HfTreeCreatorSigmacCorrBkg { aod::TracksWMc const&) { /// loop over reconstructed Σc candidates - for (auto& candidateSc : candidatesSc) { + for (auto const& candidateSc : candidatesSc) { auto candLcDauSc = candidateSc.template prongLc_as(); auto candSoftPiDauSc = candidateSc.template prong1_as(); From 21b3df1e7ba33c66db16f5c4895fb79228fb9982 Mon Sep 17 00:00:00 2001 From: mattia Date: Thu, 4 Sep 2025 15:09:57 +0200 Subject: [PATCH 3/3] Add o2linter exception. --- PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx b/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx index ccb44a33a26..1e46bfc9ea5 100644 --- a/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx +++ b/PWGHF/TableProducer/treeCreatorSigmacCorrBkg.cxx @@ -41,8 +41,8 @@ namespace o2::aod { namespace hf_sigmac_bkg { -const int pdgCodeLambdac2595 = 14122; -const int pdgCodeLambdac2625 = 4124; +const int pdgCodeLambdac2595 = 14122; // o2-linter: disable=pdg/explicit-code (PDG code needed only for this study) +const int pdgCodeLambdac2625 = 4124; // o2-linter: disable=pdg/explicit-code (PDG code needed only for this study) enum Decays { Sigmac2455Pi = 0, LambdacPiPi }; enum DecaysLambdac { PKPi = 0,