From 79af64592aa745b1f42b7c2da270ed0e094ec84e Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 27 May 2025 22:11:16 +0200 Subject: [PATCH 01/35] Created correlatorLcScHadrons.cxx --- .../TableProducer/correlatorLcScHadrons.cxx | 1082 +++++++++++++++++ 1 file changed, 1082 insertions(+) create mode 100644 PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx new file mode 100644 index 00000000000..1514d05c058 --- /dev/null +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -0,0 +1,1082 @@ +// 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 correlatorLcHadrons.cxx +/// \brief Lc-Hadrons correlator task - data-like, Mc-Reco and Mc-Gen analyses +/// +/// \author Marianna Mazzilli +/// \author Zhen Zhang +/// \author Ravindra Singh + +#include +#include "TRandom3.h" + +#include "CommonConstants/PhysicsConstants.h" +#include "Framework/AnalysisTask.h" +#include "Framework/HistogramRegistry.h" +#include "Framework/O2DatabasePDGPlugin.h" +#include "Framework/runDataProcessing.h" + +#include "Common/Core/TrackSelection.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/TrackSelectionTables.h" + +#include "PWGHF/Core/HfHelper.h" +#include "PWGHF/DataModel/CandidateReconstructionTables.h" +#include "PWGHF/DataModel/CandidateSelectionTables.h" +#include "PWGHF/HFC/DataModel/CorrelationTables.h" +#include "PWGHF/HFC/Utils/utilsCorrelations.h" + +using namespace o2; +using namespace o2::analysis; +using namespace o2::constants::physics; +using namespace o2::constants::math; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::analysis::hf_correlations; +/// +/// Returns deltaPhi values in range [-pi/2., 3.*pi/2.], typically used for correlation studies +/// +double getDeltaPhi(double phiLc, double phiHadron) +{ + return RecoDecay::constrainAngle(phiHadron - phiLc, -PIHalf); +} + +// definition of ME variables +using BinningType = ColumnBinningPolicy>; +using BinningTypeMcGen = ColumnBinningPolicy; + +// Code to select collisions with at least one Lambda_c +struct HfCorrelatorLcScHadronsSelection { + Produces lcSel; + + Configurable useSel8{"useSel8", true, "Flag for applying sel8 for collision selection"}; + Configurable selNoSameBunchPileUpColl{"selNoSameBunchPileUpColl", true, "Flag for rejecting the collisions associated with the same bunch crossing"}; + Configurable doSelLcCollision{"doSelLcCollision", true, "Select collisions with at least one Lc"}; + Configurable selectionFlagLc{"selectionFlagLc", 1, "Selection Flag for Lc"}; + Configurable yCandMax{"yCandMax", 0.8, "max. cand. rapidity"}; + Configurable ptCandMin{"ptCandMin", 1., "min. cand. pT"}; + + HfHelper hfHelper; + SliceCache cache; + + using SelCollisions = soa::Join; + using CandsLcDataFiltered = soa::Filtered>; + using CandsLcMcRecFiltered = soa::Filtered>; + using CandidatesLcMcGen = soa::Join; + + // filter on selection of Lc and decay channel Lc->PKPi + Filter lcFilter = ((o2::aod::hf_track_index::hfflag & static_cast(1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) != static_cast(0)) && (aod::hf_sel_candidate_lc::isSelLcToPKPi >= selectionFlagLc || aod::hf_sel_candidate_lc::isSelLcToPiKP >= selectionFlagLc); + + /// Code to select collisions with at least one Lc - for real data and data-like analysis + void processLcSelectionData(SelCollisions::iterator const& collision, + CandsLcDataFiltered const& candidates) + { + bool isSelColl = true; + bool isLcFound = true; + bool isSel8 = true; + bool isNosameBunchPileUp = true; + if (doSelLcCollision) { + for (const auto& candidate : candidates) { + if (std::abs(hfHelper.yLc(candidate)) > yCandMax || candidate.pt() < ptCandMin) { + isLcFound = false; + continue; + } + isLcFound = true; + break; + } + } + if (useSel8) { + isSel8 = collision.sel8(); + } + if (selNoSameBunchPileUpColl) { + isNosameBunchPileUp = static_cast(collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)); + } + isSelColl = isLcFound && isSel8 && isNosameBunchPileUp; + lcSel(isSelColl); + } + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionData, "Process Lc Collision Selection Data", true); + + void processLcSelectionMcRec(SelCollisions::iterator const& collision, + CandsLcMcRecFiltered const& candidates) + { + bool isSelColl = true; + bool isLcFound = true; + bool isSel8 = true; + bool isNosameBunchPileUp = true; + if (doSelLcCollision) { + for (const auto& candidate : candidates) { + if (std::abs(hfHelper.yLc(candidate)) > yCandMax || candidate.pt() < ptCandMin) { + isLcFound = false; + continue; + } + isLcFound = true; + break; + } + } + if (useSel8) { + isSel8 = collision.sel8(); + } + if (selNoSameBunchPileUpColl) { + isNosameBunchPileUp = static_cast(collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)); + } + isSelColl = isLcFound && isSel8 && isNosameBunchPileUp; + lcSel(isSelColl); + } + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); + + void processLcSelectionMcGen(aod::McCollision const&, + CandidatesLcMcGen const& mcParticles) + { + bool isLcFound = true; + for (const auto& particle : mcParticles) { + if (std::abs(particle.pdgCode()) != Pdg::kLambdaCPlus) { + isLcFound = false; + continue; + } + double yL = RecoDecay::y(particle.pVector(), MassLambdaCPlus); + if (std::abs(yL) > yCandMax || particle.pt() < ptCandMin) { + isLcFound = false; + continue; + } + isLcFound = true; + break; + } + lcSel(isLcFound); + } + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcGen, "Process Lc Selection McGen", false); +}; + +// Lc-Hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via Mc truth) +struct HfCorrelatorLcScHadrons { + Produces entryCandHadronPair; + Produces entryCandHadronPairY; + Produces entryCandHadronPairTrkPID; + Produces entryCandHadronRecoInfo; + Produces entryCandHadronMlInfo; + Produces entryCandCandRecoInfo; + Produces entryCandHadronGenInfo; + Produces entryCandCandGenInfo; + Produces entryTrackRecoInfo; + Produces entryCand; + Produces entryHadron; + Produces entryTrkPID; + Produces entryPairCandCharge; + Produces entryCandCharge; + + + Configurable selectionFlagLc{"selectionFlagLc", 1, "Selection Flag for Lc"}; + Configurable numberEventsMixed{"numberEventsMixed", 5, "number of events mixed in ME process"}; + Configurable applyEfficiency{"applyEfficiency", 1, "Flag for applying Lc efficiency weights"}; + Configurable yCandMax{"yCandMax", 0.8, "max. cand. rapidity"}; + Configurable yCandGenMax{"yCandGenMax", 0.5, "max. gen. cand. rapidity"}; + Configurable etaTrackMax{"etaTrackMax", 0.8, "max. eta of tracks"}; + Configurable dcaXYTrackMax{"dcaXYTrackMax", 1., "max. DCAxy of tracks"}; + Configurable dcaZTrackMax{"dcaZTrackMax", 1., "max. DCAz of tracks"}; + Configurable ptCandMin{"ptCandMin", 1., "min. cand. pT"}; + Configurable ptCandMax{"ptCandMax", 50., "max. cand. pT"}; + Configurable ptTrackMin{"ptTrackMin", 0.3, "min. track pT"}; + Configurable ptTrackMax{"ptTrackMax", 50., "max. track pT"}; + Configurable multMin{"multMin", 0., "minimum multiplicity accepted"}; + Configurable multMax{"multMax", 10000., "maximum multiplicity accepted"}; + Configurable> classMl{"classMl", {0, 1, 2}, "Indexes of ML scores to be stored. Three indexes max."}; + Configurable> binsPtLc{"binsPtLc", std::vector{o2::analysis::hf_cuts_lc_to_p_k_pi::vecBinsPt}, "pT bin limits for candidate mass plots"}; + Configurable> binsPtHadron{"binsPtHadron", std::vector{0.3, 2., 4., 8., 12., 50.}, "pT bin limits for assoc particle"}; + Configurable> binsPtEfficiencyLc{"binsPtEfficiencyLc", std::vector{o2::analysis::hf_cuts_lc_to_p_k_pi::vecBinsPt}, "pT bin limits for efficiency"}; + Configurable> efficiencyLc{"efficiencyLc", {1., 1., 1., 1., 1., 1.}, "efficiency values for Lc"}; + Configurable storeAutoCorrelationFlag{"storeAutoCorrelationFlag", false, "Store flag that indicates if the track is paired to its Lc mother instead of skipping it"}; + Configurable correlateLcWithLeadingParticle{"correlateLcWithLeadingParticle", false, "Switch for correlation of Lc baryons with leading particle only"}; + Configurable pidTrkApplied{"pidTrkApplied", false, "Apply PID selection for associated tracks"}; + Configurable> trkPIDspecies{"trkPIDspecies", std::vector{o2::track::PID::Proton, o2::track::PID::Pion, o2::track::PID::Kaon}, "Trk sel: Particles species for PID, proton, pion, kaon"}; + Configurable> pidTPCMax{"pidTPCMax", std::vector{3., 0., 0.}, "maximum nSigma TPC"}; + Configurable> pidTOFMax{"pidTOFMax", std::vector{3., 0., 0.}, "maximum nSigma TOF"}; + Configurable tofPIDThreshold{"tofPIDThreshold", 0.75, "minimum pT after which TOF PID is applicable"}; + Configurable fillTrkPID{"fillTrkPID", false, "fill PID information for associated tracks"}; + Configurable forceTOF{"forceTOF", false, "fill PID information for associated tracks"}; + Configurable calTrkEff{"calTrkEff", false, "fill histograms to calculate efficiency"}; + Configurable isRecTrkPhyPrimary{"isRecTrkPhyPrimary", true, "Calculate the efficiency of reconstructed primary physical tracks"}; + Configurable calEffEventWithCand{"calEffEventWithCand", true, "Calculate the efficiency of Lc candidate"}; + Configurable eventFractionToAnalyze{"eventFractionToAnalyze", -1, "Fraction of events to analyze (use only for ME offline on very large samples)"}; + + HfHelper hfHelper; + SliceCache cache; + Service pdg; + int leadingIndex = 0; + int poolBin = 0; + int poolBinLc = 0; + bool correlationStatus = false; + bool isPrompt = false; + bool isNonPrompt = false; + bool isSignal = false; + + static constexpr size_t nDaughters{3u}; + TRandom3* rnd = new TRandom3(0); + std::vector outputMl = {-1., -1., -1.}; + std::vector outputMlPKPi = {-1., -1., -1.}; + std::vector outputMlPiKP = {-1., -1., -1.}; + + // Event Mixing for the Data Mode + using SelCollisionsWithSc = soa::Join; + using SelCollisionsWithLc = soa::Filtered>; + using SelCollisionsWithLcMc = soa::Filtered>; // collisionFilter applied + + using CandsLcData = soa::Join; + using CandsLcDataFiltered = soa::Filtered; + + // Event Mixing for the MCRec Mode + using CandsLcMcRec = soa::Join; + using CandsLcMcRecFiltered = soa::Filtered; + using CandidatesLcMcGen = soa::Join; // flagLcFilter applied + // Event Mixing for the MCGen Mode + using McCollisionsSel = soa::Filtered>; + using McParticlesSel = soa::Filtered; + // Tracks used in Data and MC + using TracksData = soa::Filtered>; // trackFilter applied + using TracksWithMc = soa::Filtered>; // trackFilter applied + // Filters for ME + Filter collisionFilter = aod::hf_selection_lc_collision::lcSel == true; + Filter lcFilter = ((o2::aod::hf_track_index::hfflag & static_cast(1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) != static_cast(0)) && (aod::hf_sel_candidate_lc::isSelLcToPKPi >= selectionFlagLc || aod::hf_sel_candidate_lc::isSelLcToPiKP >= selectionFlagLc); + Filter trackFilter = (nabs(aod::track::eta) < etaTrackMax) && (nabs(aod::track::pt) > ptTrackMin) && (nabs(aod::track::dcaXY) < dcaXYTrackMax) && (nabs(aod::track::dcaZ) < dcaZTrackMax); + + // Preslice perTrueCollision = o2::aod::mcparticle::McCollisionId; + Preslice perTrueCollision = o2::aod::mcparticle::mcCollisionId; + // configurable axis definition + ConfigurableAxis binsMultiplicity{"binsMultiplicity", {VARIABLE_WIDTH, 0.0f, 2000.0f, 6000.0f, 100000.0f}, "Mixing bins - multiplicity"}; + ConfigurableAxis binsZVtx{"binsZVtx", {VARIABLE_WIDTH, -10.0f, -2.5f, 2.5f, 10.0f}, "Mixing bins - z-vertex"}; + ConfigurableAxis binsMultiplicityMc{"binsMultiplicityMc", {VARIABLE_WIDTH, 0.0f, 20.0f, 50.0f, 500.0f}, "Mixing bins - MC multiplicity"}; // In MCGen multiplicity is defined by counting tracks + ConfigurableAxis binsBdtScore{"binsBdtScore", {100, 0., 1.}, "Bdt output scores"}; + ConfigurableAxis binsEta{"binsEta", {50, -2., 2.}, "#it{#eta}"}; + ConfigurableAxis binsPhi{"binsPhi", {64, -PIHalf, 3. * PIHalf}, "#it{#varphi}"}; + ConfigurableAxis binsPoolBin{"binsPoolBin", {9, 0., 9.}, "PoolBin"}; + ConfigurableAxis binsMultFT0M{"binsMultFT0M", {600, 0., 6000.}, "Multiplicity as FT0M signal amplitude"}; + ConfigurableAxis binsCandMass{"binsCandMass", {200, 1.98, 2.58}, "inv. mass (p K #pi) (GeV/#it{c}^{2})"}; + + BinningType corrBinning{{binsZVtx, binsMultiplicity}, true}; + + HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject}; + void init(InitContext&) + { + AxisSpec axisCandMass = {binsCandMass, "inv. mass (p K #pi) (GeV/#it{c}^{2})"}; + AxisSpec axisEta = {binsEta, "#it{eta}"}; + AxisSpec axisPhi = {binsPhi, "#it{#varphi}"}; + AxisSpec axisPtLc = {(std::vector)binsPtLc, "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec axisPtHadron = {(std::vector)binsPtHadron, "#it{p}_{T} Hadron (GeV/#it{c})"}; + AxisSpec axisPtTrack = {500, 0, 50, "#it{p}_{T} Hadron (GeV/#it{c})"}; + AxisSpec axisMultiplicity = {binsMultiplicity, "Multiplicity"}; + AxisSpec axisMultFT0M = {binsMultFT0M, "MultiplicityFT0M"}; + AxisSpec axisPosZ = {binsZVtx, "PosZ"}; + AxisSpec axisBdtScore = {binsBdtScore, "Bdt score"}; + AxisSpec axisPoolBin = {binsPoolBin, "PoolBin"}; + AxisSpec axisRapidity = {100, -2, 2, "Rapidity"}; + AxisSpec axisSign = {2, -1, 1, "Sign"}; + + registry.add("hPtCand", "Lc,Hadron candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtProng0", "Lc,Hadron candidates;prong 0 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtProng1", "Lc,Hadron candidates;prong 1 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtProng2", "Lc,Hadron candidates;prong 2 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); + registry.add("hSelectionStatusLcToPKPi", "Lc,Hadron candidates;selection status;entries", {HistType::kTH1F, {{8, -0.5, 7.5}}}); + registry.add("hSelectionStatusLcToPiKP", "Lc,Hadron candidates;selection status;entries", {HistType::kTH1F, {{8, -0.5, 7.5}}}); + registry.add("hEta", "Lc,Hadron candidates;candidate #it{#eta};entries", {HistType::kTH1F, {axisEta}}); + registry.add("hPhi", "Lc,Hadron candidates;candidate #it{#varphi};entries", {HistType::kTH1F, {axisPhi}}); + registry.add("hcountCandHadronPerEvent", "Lc,Hadron particles - MC gen;Number per event;entries", {HistType::kTH1F, {{21, -0.5, 20.5}}}); + registry.add("hMultiplicityPreSelection", "multiplicity prior to selection;multiplicity;entries", {HistType::kTH1F, {{10000, 0., 10000.}}}); + registry.add("hMultiplicity", "multiplicity;multiplicity;entries", {HistType::kTH1F, {{10000, 0., 10000.}}}); + registry.add("hMultFT0M", "multiplicity;multiplicity;entries", {HistType::kTH1F, {{10000, 0., 10000.}}}); + registry.add("hZvtx", "z vertex;z vertex;entries", {HistType::kTH1F, {{200, -20., 20.}}}); + registry.add("hCandBin", "Lc selected in pool Bin;pool Bin;entries", {HistType::kTH1F, {{9, 0., 9.}}}); + registry.add("hTracksBin", "Tracks selected in pool Bin;pool Bin;entries", {HistType::kTH1F, {{9, 0., 9.}}}); + registry.add("hMassLcVsPt", "Lc candidates;inv. mass (p K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{axisCandMass}, {axisPtLc}}}); + registry.add("hMassLcData", "Lc candidates;inv. mass (p K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{axisCandMass}}}); + registry.add("hLcPoolBin", "Lc candidates pool bin", {HistType::kTH1F, {axisPoolBin}}); + registry.add("hTracksPoolBin", "Particles associated pool bin", {HistType::kTH1F, {axisPoolBin}}); + // Histograms for MC Reco analysis + registry.add("hMcEvtCount", "Event counter - MC gen;;entries", {HistType::kTH1F, {{1, -0.5, 0.5}}}); + registry.add("hMassLcMcRecBkg", "Lc background candidates - MC reco;inv. mass (p K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{axisCandMass}, {axisPtLc}}}); + registry.add("hPtCandSig", "Lc,Hadron candidates - MC Reco", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtCandSigPrompt", "Lc,Hadron candidates Prompt - MC Reco", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtCandSigNonPrompt", "Lc,Hadron candidates Non Prompt - MC Reco", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtCandMcRecBkg", "Lc,Hadron candidates - MC Reco", {HistType::kTH1F, {axisPtLc}}); + registry.add("hEtaSig", "Lc,Hadron candidates - MC Reco", {HistType::kTH1F, {axisEta}}); + registry.add("hPhiSig", "Lc,Hadron candidates - MC Reco", {HistType::kTH1F, {axisPhi}}); + registry.add("hY", "Lc,Hadron candidates;candidate #it{#y};entries", {HistType::kTH1F, {axisRapidity}}); + registry.add("hYSig", "Lc,Hadron candidates - MC reco;candidate #it{#y};entries", {HistType::kTH1F, {axisRapidity}}); + registry.add("hPtCandMcRecSigPrompt", "Lc,Hadron candidates Prompt - MC Reco", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtCandMcRecSigNonPrompt", "Lc,Hadron candidates Non Prompt - MC Reco", {HistType::kTH1F, {axisPtLc}}); + registry.add("hEtaMcRecBkg", "Lc,Hadron candidates - MC Reco", {HistType::kTH1F, {axisEta}}); + registry.add("hPhiMcRecBkg", "Lc,Hadron candidates - MC Reco", {HistType::kTH1F, {axisPhi}}); + registry.add("hYMcRecBkg", "Lc,Hadron candidates - MC reco;candidate #it{#y};entries", {HistType::kTH1F, {axisRapidity}}); + registry.add("hFakeTracksMcRec", "Fake tracks - MC Rec", {HistType::kTH1F, {axisPtHadron}}); + registry.add("hPtParticleAssocVsCandMcRec", "Associated Particle - MC Rec", {HistType::kTH2F, {{axisPtHadron}, {axisPtLc}}}); + registry.add("hPtTracksVsSignRec", "Associated Particle - MC Rec", {HistType::kTH2F, {{axisPtTrack}, {axisSign}}}); + registry.add("hPtTracksVsSignRecTrue", "Associated Particle - MC Rec (True)", {HistType::kTH2F, {{axisPtTrack}, {axisSign}}}); + registry.add("hPtTracksVsSignGen", "Associated Particle - MC Gen", {HistType::kTH2F, {{axisPtTrack}, {axisSign}}}); + registry.add("hPtPrimaryParticleAssocVsCandMcRec", "Associated Particle - MC Rec", {HistType::kTH2F, {{axisPtHadron}, {axisPtLc}}}); + registry.add("hPtVsMultiplicityMcRecPrompt", "Multiplicity FT0M - MC Rec Prompt", {HistType::kTH2F, {{axisPtLc}, {axisMultFT0M}}}); + registry.add("hPtVsMultiplicityMcRecNonPrompt", "Multiplicity FT0M - MC Rec Non Prompt", {HistType::kTH2F, {{axisPtLc}, {axisMultFT0M}}}); + // Histograms for MC Gen analysis + registry.add("hcountCandtriggersMcGen", "Lc trigger particles - MC gen;;N of trigger Lc", {HistType::kTH2F, {{1, -0.5, 0.5}, {axisPtLc}}}); + registry.add("hPtCandMcGen", "Lc,Hadron particles - MC gen;particle #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); + registry.add("hYMcGen", "Lc,Hadron candidates - MC gen;candidate #it{#y};entries", {HistType::kTH1F, {axisRapidity}}); + registry.add("hPtCandMcGenPrompt", "Lc,Hadron particles - MC Gen Prompt", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtCandMcGenNonPrompt", "Lc,Hadron particles - MC Gen Non Prompt", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtParticleAssocMcGen", "Associated Particle - MC Gen", {HistType::kTH1F, {axisPtHadron}}); + registry.add("hEtaMcGen", "Lc,Hadron particles - MC Gen", {HistType::kTH1F, {axisEta}}); + registry.add("hPhiMcGen", "Lc,Hadron particles - MC Gen", {HistType::kTH1F, {axisPhi}}); + registry.add("hMultFT0AMcGen", "Lc,Hadron multiplicity FT0A - MC Gen", {HistType::kTH1F, {axisMultiplicity}}); + + corrBinning = {{binsZVtx, binsMultiplicity}, true}; + + } + + template + void fillMlOutput(mlProbType& mlProb, std::vector& outputMl) { + for (unsigned int iclass = 0; iclass < classMl->size(); iclass++) { + outputMl[iclass] = mlProb[classMl->at(iclass)]; + } + }; + + template + double estimateY(candtype& cand) + { + double y = -999.; + if constexpr (isCandSc){ + int8_t chargeCand = cand.charge(); + + if (chargeCand == 0) { + y = hfHelper.ySc0(cand); + } else { + y = hfHelper.yScPlusPlus(cand); + } + + } else { + y = hfHelper.yLc(cand); + } + return y; + } + + template + int isDecayToPKPiToPiKP(L& candidateLc, S& candSc) + { + int channel = 0; + if ((candidateLc.isSelLcToPKPi() >= 1) && candSc.statusSpreadLcMinvPKPiFromPDG()) { + // Λc+ → pK-π+ and within the requested mass to build the Σc0,++ + channel += 1; + } + if ((candidateLc.isSelLcToPiKP() >= 1) && candSc.statusSpreadLcMinvPiKPFromPDG()) { + // Λc+ → π+K-p and within the requested mass to build the Σc0,++ + channel += 2; + } + return channel; /// 0: none; 1: pK-π+ only; 2: π+K-p only; 3: both possible + } + + template + void calculateTrkEff(t1& trackPos1, t2& trackPos2, mcPart& mcParticles){ + // genrated tracks + decltype(trackPos1.template mcParticle_as()) mctrk{}; + if (trackPos1.has_mcParticle()) { // ambiguous tracks should be small + mctrk = trackPos1.template mcParticle_as(); + } else if (trackPos2.has_mcParticle()) { + mctrk = trackPos2.template mcParticle_as(); + } else { + return; + } + auto gentracks = mcParticles.sliceBy(perTrueCollision, mctrk.mcCollisionId()); + for (const auto& track : gentracks) { + if (std::abs(track.eta()) > etaTrackMax || track.pt() < ptTrackMin || track.pt() > ptTrackMax) { + continue; + } + if ((std::abs(track.pdgCode()) != kElectron) && (std::abs(track.pdgCode()) != kMuonMinus) && (std::abs(track.pdgCode()) != kPiPlus) && (std::abs(track.pdgCode()) != kKPlus) && (std::abs(track.pdgCode()) != kProton)) { + continue; + } + + if (pidTrkApplied && (std::abs(track.pdgCode()) != kProton)) + continue; // proton PID + + if (!track.isPhysicalPrimary()) { + continue; + } + + auto motherTrkGen = mcParticles.iteratorAt(track.mothersIds()[0]); + if (std::abs(motherTrkGen.pdgCode()) == kLambdaCPlus) + continue; + + auto chargeTrack = pdg->GetParticle(track.pdgCode())->Charge(); // Retrieve charge + registry.fill(HIST("hPtTracksVsSignGen"), track.pt(), chargeTrack / (2 * std::abs(chargeTrack))); + } + } + template + void fillCorrelationTable(bool trkPidFill, tracktype& trk, candtype& cand, std::vector outMl, int binPool, int8_t correlStatus, double candY, int signCand, mcPart& mcParticles) + { + bool isPhysicalPrimary = false; + int trackOrigin = -1; + + entryCandHadronPair(getDeltaPhi(trk.phi(), cand.phi()), + trk.eta() - cand.eta(), + cand.pt(), + trk.pt() * trk.sign(), + binPool, + correlStatus); +entryCandHadronPairY(trk.y() - candY); +entryCandHadronMlInfo(outMl[0], outMl[1]); +entryTrackRecoInfo(trk.dcaXY(), trk.dcaZ(), trk.tpcNClsCrossedRows()); +entryPairCandCharge(signCand); +if (trkPidFill) { +entryCandHadronPairTrkPID(trk.tpcNSigmaPr(), trk.tpcNSigmaKa(), trk.tpcNSigmaPi(), trk.tofNSigmaPr(), trk.tofNSigmaKa(), trk.tofNSigmaPi()); +} +if constexpr (isMcRec){ + if (trk.has_mcParticle()) { + auto mcParticle = trk.template mcParticle_as(); + isPhysicalPrimary = mcParticle.isPhysicalPrimary(); + trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, mcParticle, true); + entryCandHadronGenInfo(isPrompt, isPhysicalPrimary, trackOrigin); + } else { + entryCandHadronGenInfo(isPrompt, false, 0); + registry.fill(HIST("hFakeTracksMcRec"), trk.pt()); + } + registry.fill(HIST("hPtParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); + if (isPhysicalPrimary) { + registry.fill(HIST("hPtPrimaryParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); + } +} + } + + template + void doSameEvent(CollisionType const& collision, + TrackType const& tracks, + CandType const& candidates, + aod::McParticles const* mcParticles = nullptr) { + + int nTracks = 0; + int64_t timeStamp = 0; + bool skipMixedEventTableFilling = false; + float multiplicityFT0M = collision.multFT0M(); + int gCollisionId = collision.globalIndex(); + if (candidates.size() == 0) { + return; + } + + if (eventFractionToAnalyze > 0) { + if (rnd->Uniform(0, 1) > eventFractionToAnalyze) { + skipMixedEventTableFilling = true; + } + } + + if constexpr (!isMcRec) { + timeStamp = collision.template bc_as().timestamp(); + } + + poolBin = corrBinning.getBin(std::make_tuple(collision.posZ(), multiplicityFT0M)); + if (correlateLcWithLeadingParticle) { + leadingIndex = findLeadingParticle(tracks, etaTrackMax.value); + } + + // Count good tracks + if (collision.numContrib() > 1) { + for (const auto& track : tracks) { + if (std::abs(track.eta()) > etaTrackMax || std::abs(track.dcaXY()) > dcaXYTrackMax || std::abs(track.dcaZ()) > dcaZTrackMax) { + continue; + } + nTracks++; + } + } + + registry.fill(HIST("hMultiplicityPreSelection"), nTracks); + if (nTracks < multMin || nTracks > multMax) { + return; + } + registry.fill(HIST("hMultiplicity"), nTracks); + + int countCand = 1; + + for (const auto& candidate : candidates) { + + int8_t chargeCand = 3; + double efficiencyWeightCand = 1.; + double yCand = -999.0; + double etaCand = -999.0; + double ptCandLc = -999.0; + double ptCand = -999.0; + double phiCand = -999.0; + double massCandPKPi = -999.0; + double massCandPiKP = -999.0; + bool selLcPKPi = false; + bool selLcPiKP = false; + + yCand = estimateY(candidate); + etaCand = candidate.eta(); + ptCand = candidate.pt(); + phiCand = RecoDecay::constrainAngle(candidate.phi(), -PIHalf); + + if ((std::abs(yCand) > yCandMax) || ptCand < ptCandMin || ptCand > ptCandMax) { + continue; + } + + registry.fill(HIST("hY"), yCand); + registry.fill(HIST("hPtCand"), ptCand); + registry.fill(HIST("hEta"), etaCand); + registry.fill(HIST("hPhi"), phiCand); + registry.fill(HIST("hCandBin"), poolBin); + + if (applyEfficiency) { + efficiencyWeightCand = 1. / efficiencyLc->at(o2::analysis::findBin(binsPtEfficiencyLc, ptCand)); + } + + if constexpr (isMcRec){ + isPrompt = candidate.originMcRec() == RecoDecay::OriginType::Prompt; + isNonPrompt = candidate.originMcRec() == RecoDecay::OriginType::NonPrompt; + } + + if constexpr (isCandSc) { + chargeCand = candidate.charge(); + const auto& candidateLc = candidate.template prongLc_as(); + ptCandLc = candidateLc.pt(); + selLcPKPi = (candidateLc.isSelLcToPKPi() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPKPiFromPDG()); + selLcPiKP = (candidateLc.isSelLcToPiKP() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPiKPFromPDG()); + if(selLcPKPi){ + const auto& probs = candidateLc.mlProbLcToPKPi(); + fillMlOutput(probs,outputMlPKPi); + massCandPKPi = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); + } + if(selLcPiKP){ + const auto& probs = candidateLc.mlProbLcToPiKP(); + fillMlOutput(probs,outputMlPiKP); + massCandPiKP = hfHelper.invMassScRecoLcToPiKP(candidate, candidateLc); + } + if constexpr (isMcRec) { + //isSignal = + // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || + // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + isSignal = + (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || + (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + + auto trackPos1 = candidateLc.template prong0_as(); + auto trackPos2 = candidateLc.template prong2_as(); + if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand)) { + calculateTrkEff(trackPos1, trackPos2, *mcParticles); + } + registry.fill(HIST("hPtProng1"), candidate.template prong1_as().pt()); + } else { + registry.fill(HIST("hPtProng1"), candidate.prong1().pt()); + } + registry.fill(HIST("hPtProng0"), ptCandLc); + } else { + selLcPKPi = candidate.isSelLcToPKPi() >= selectionFlagLc; + selLcPiKP = candidate.isSelLcToPiKP() >= selectionFlagLc; + if(selLcPKPi){ + const auto& probs = candidate.mlProbLcToPKPi(); + fillMlOutput(probs,outputMlPKPi); + massCandPKPi = hfHelper.invMassLcToPKPi(candidate); + } + if(selLcPiKP){ + const auto& probs = candidate.mlProbLcToPiKP(); + fillMlOutput(probs,outputMlPiKP); + massCandPiKP = hfHelper.invMassLcToPiKP(candidate); + } + auto trackPos1 = candidate.template prong0_as(); + auto trackPos2 = candidate.template prong2_as(); + chargeCand = trackPos1.sign(); + if constexpr (isMcRec){ + isSignal = TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi); + if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand)) { + calculateTrkEff(trackPos1, trackPos2, *mcParticles); + } + } + registry.fill(HIST("hPtProng0"), candidate.ptProng0()); + registry.fill(HIST("hPtProng1"), candidate.ptProng1()); + registry.fill(HIST("hPtProng2"), candidate.ptProng2()); + } + + if (isSignal){ + registry.fill(HIST("hPtCandSig"), ptCand); + registry.fill(HIST("hEtaSig"), ptCand); + registry.fill(HIST("hPhiSig"), phiCand); + registry.fill(HIST("hYSig"), yCand); + } + + if (selLcPKPi) { + registry.fill(HIST("hMassLcVsPt"), massCandPKPi, ptCand, efficiencyWeightCand); + registry.fill(HIST("hMassLcData"), massCandPKPi, efficiencyWeightCand); + registry.fill(HIST("hSelectionStatusLcToPKPi"), selLcPKPi); + if (isPrompt) { + registry.fill(HIST("hPtCandSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, multiplicityFT0M); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, multiplicityFT0M); + } + + entryCandCandRecoInfo(massCandPKPi, ptCand, outputMlPKPi[0], outputMlPKPi[1]); + entryCandCandGenInfo(isPrompt); + if (!skipMixedEventTableFilling) { + entryCand(candidate.phi(),etaCand, ptCand, massCandPKPi, poolBin, gCollisionId, timeStamp); + entryCandCharge(chargeCand); + } + } + + if (selLcPiKP) { + registry.fill(HIST("hMassLcVsPt"), massCandPiKP, ptCand, efficiencyWeightCand); + registry.fill(HIST("hMassLcData"), massCandPiKP, efficiencyWeightCand); + registry.fill(HIST("hSelectionStatusLcToPiKP"), selLcPiKP); + if (isPrompt) { + registry.fill(HIST("hPtCandSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, multiplicityFT0M); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, multiplicityFT0M); + } + entryCandCandRecoInfo(massCandPiKP, ptCand, outputMlPiKP[0], outputMlPiKP[1]); + entryCandCandGenInfo(isPrompt); + if (!skipMixedEventTableFilling) { + entryCand(candidate.phi(), etaCand, ptCand, massCandPiKP, poolBin, gCollisionId, timeStamp); + entryCandCharge(chargeCand); + } + } + + registry.fill(HIST("hCandBin"), poolBin); + // Correlation with hadrons + for (const auto& track : tracks) { + // Remove Lc daughters by checking track indices + if constexpr (!isCandSc){ + if ((candidate.prong0Id() == track.globalIndex()) || (candidate.prong1Id() == track.globalIndex()) || (candidate.prong2Id() == track.globalIndex())) { + if (!storeAutoCorrelationFlag) { + continue; + } + correlationStatus = true; + }} else { + const auto& candidateLc = candidate.template prongLc_as(); + if ((candidateLc.prong0Id() == track.globalIndex()) || (candidateLc.prong1Id() == track.globalIndex()) || (candidateLc.prong2Id() == track.globalIndex()) || (candidate.prong1Id() == track.globalIndex())) { + if (!storeAutoCorrelationFlag) { + continue; + } + correlationStatus = true; + } + } + if (!track.isGlobalTrackWoDCA()) { + continue; + } + if (pidTrkApplied) { + if (!passPIDSelection(track, trkPIDspecies, pidTPCMax, pidTOFMax, tofPIDThreshold, forceTOF)) + continue; + } + if (correlateLcWithLeadingParticle) { + if (track.globalIndex() != leadingIndex) { + continue; + } + } + if constexpr (isMcRec){ + if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand) && track.has_mcParticle()) { + auto mcParticle = track.template mcParticle_as(); + if (!mcParticle.isPhysicalPrimary() && isRecTrkPhyPrimary) + continue; + + auto motherTrk = mcParticles->iteratorAt(mcParticle.mothersIds()[0]); + if (std::abs(motherTrk.pdgCode()) == kLambdaCPlus) + continue; + + + registry.fill(HIST("hPtTracksVsSignRec"), track.pt(), track.sign() / 2.); + if (std::abs(mcParticle.pdgCode()) == kProton) + registry.fill(HIST("hPtTracksVsSignRecTrue"), track.pt(), track.sign() / 2.); + } + } + + if (selLcPKPi) { + fillCorrelationTable(fillTrkPID, track, candidate, outputMlPKPi, poolBin, correlationStatus, yCand, chargeCand,*mcParticles); + entryCandHadronRecoInfo(massCandPKPi, false); + } + if (selLcPiKP) { + fillCorrelationTable(fillTrkPID, track, candidate, outputMlPiKP, poolBin, correlationStatus, yCand, chargeCand, *mcParticles); + entryCandHadronRecoInfo(massCandPiKP, false); + } + + if (countCand == 1) { + if (!skipMixedEventTableFilling) { + entryHadron(track.phi(), track.eta(), track.pt() * track.sign(), poolBin, gCollisionId, timeStamp); + if (fillTrkPID) { + entryTrkPID(track.tpcNSigmaPr(), track.tpcNSigmaKa(), track.tpcNSigmaPi(), track.tofNSigmaPr(), track.tofNSigmaKa(), track.tofNSigmaPi()); + } + registry.fill(HIST("hTracksBin"), poolBin); + } + } + } // Hadron Tracks loop + countCand++; + } // end outer Lc loop + registry.fill(HIST("hZvtx"), collision.posZ()); + registry.fill(HIST("hMultFT0M"), multiplicityFT0M); + + } + + template + void doMixEvent(CollisionType const& collisions, + TrackType const& tracks, + CandType const& candidates, + aod::McParticles const* mcParticles = nullptr) { + + if (candidates.size() == 0){ + return; + } + + double yCand = -999.; + double ptCand = -999.; + int8_t chargeCand = 3; + double massCandPKPi = -999.0; + double massCandPiKP = -999.0; + bool selLcPKPi = false; + bool selLcPiKP = false; + + auto tracksTuple = std::make_tuple(candidates, tracks); + Pair pairData{corrBinning, numberEventsMixed, -1, collisions, tracksTuple, &cache}; + + for (const auto& [c1, tracks1, c2, tracks2] : pairData) { + poolBin = corrBinning.getBin(std::make_tuple(c2.posZ(), c2.multFT0M())); + poolBinLc = corrBinning.getBin(std::make_tuple(c1.posZ(), c1.multFT0M())); + registry.fill(HIST("hMultFT0M"), c1.multFT0M()); + registry.fill(HIST("hZvtx"), c1.posZ()); + registry.fill(HIST("hTracksPoolBin"), poolBin); + registry.fill(HIST("hLcPoolBin"), poolBinLc); + for (const auto& [candidate, assocParticle] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) { + + yCand = estimateY(candidate); + ptCand = candidate.pt(); + if constexpr (isMcRec){ + isPrompt = candidate.originMcRec() == RecoDecay::OriginType::Prompt; + isNonPrompt = candidate.originMcRec() == RecoDecay::OriginType::NonPrompt; + } + + if constexpr (isCandSc) { + const auto& candidateLc = candidate.template prongLc_as(); + chargeCand = candidate.charge(); + selLcPKPi = (candidateLc.isSelLcToPKPi() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPKPiFromPDG()); + selLcPiKP = (candidateLc.isSelLcToPiKP() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPiKPFromPDG()); + if (selLcPKPi) { + const auto& probs = candidateLc.mlProbLcToPKPi(); + fillMlOutput(probs,outputMlPKPi); + massCandPKPi = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); + } + if (selLcPiKP){ + const auto& probs = candidateLc.mlProbLcToPiKP(); + fillMlOutput(probs,outputMlPiKP); + massCandPiKP = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); + } + if constexpr (isMcRec) { + isSignal = + (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || + (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + } + } else { + selLcPKPi = candidate.isSelLcToPKPi() >= selectionFlagLc; + selLcPiKP = candidate.isSelLcToPiKP() >= selectionFlagLc; + if (selLcPKPi) { + const auto& probs = candidate.mlProbLcToPKPi(); + fillMlOutput(probs,outputMlPKPi); + massCandPKPi = hfHelper.invMassLcToPKPi(candidate); + } + if (selLcPiKP){ + const auto& probs = candidate.mlProbLcToPiKP(); + fillMlOutput(probs,outputMlPiKP); + massCandPiKP = hfHelper.invMassLcToPiKP(candidate); + } + auto trackPos1 = candidate.template prong0_as(); + chargeCand = trackPos1.sign(); + if constexpr (isMcRec){ + isSignal = TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi); + } + } + + if (!assocParticle.isGlobalTrackWoDCA() || std::abs(yCand) > yCandMax) { + continue; + } + + if (pidTrkApplied) { + if (!passPIDSelection(assocParticle, trkPIDspecies, pidTPCMax, pidTOFMax, tofPIDThreshold, forceTOF)) + continue; + } + + if (selLcPKPi){ + fillCorrelationTable(fillTrkPID, assocParticle, candidate, outputMlPKPi, poolBin, correlationStatus, yCand, chargeCand,*mcParticles); + entryCandHadronRecoInfo(massCandPKPi, false); + + if (isPrompt) { + registry.fill(HIST("hPtCandMcRecSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, 0); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandMcRecSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, 0); + } + } + + if (selLcPiKP){ + fillCorrelationTable(fillTrkPID, assocParticle, candidate, outputMlPiKP, poolBin, correlationStatus, yCand, chargeCand, *mcParticles); + entryCandHadronRecoInfo(massCandPiKP, false); + + if (isPrompt) { + registry.fill(HIST("hPtCandMcRecSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, 0); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandMcRecSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, 0); + } + } + + } + } + } + + //} + + /// Lc-hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via MC truth) + void processDataLc(SelCollisionsWithLc::iterator const& collision, + TracksData const& tracks, + CandsLcDataFiltered const& candidates, aod::BCsWithTimestamps const&) + { + doSameEvent(collision, tracks, candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataLc, "Process data", true); + + +void processDataSc(SelCollisionsWithSc::iterator const& collision, + TracksData const& tracks, + aod::Tracks const&, + aod::HfCandSc const& candidates, CandsLcData const&, + aod::BCsWithTimestamps const&) // MUST be last among index-compatible +{ + doSameEvent(collision, tracks, candidates); +} +PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataSc, "Process data Sc", false); + + /// Lc-Hadron correlation process starts for McRec + void processMcRecLc(SelCollisionsWithLc::iterator const& collision, + TracksWithMc const& tracks, + CandsLcMcRecFiltered const& candidates, + aod::McParticles const& mcParticles) + { + doSameEvent(collision, tracks, candidates, &mcParticles); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecLc, "Process Mc Reco mode", false); + + /// Lc-Hadron correlation process starts for McRec + void processMcRecSc(SelCollisionsWithSc::iterator const& collision, + TracksWithMc const& tracks, + aod::TracksWMc const&, + soa::Join const& candidates, + CandsLcData const&, + aod::McParticles const& mcParticles) +{ +doSameEvent(collision, tracks, candidates, &mcParticles); +} +PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecSc, "Process Mc Reco mode", false); + + void processDataMixedEventSc(SelCollisionsWithSc const& collisions, + TracksData const& tracks, + aod::Tracks const&, + aod::HfCandSc const& candidates, CandsLcData const&) + { + doMixEvent(collisions, tracks, candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataMixedEventSc, "Process Mixed Event Data", false); + + void processDataMixedEventLc(SelCollisionsWithLc const& collisions, + CandsLcDataFiltered const& candidates, + TracksData const& tracks) + { + + doMixEvent(collisions, tracks, candidates); + + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataMixedEventLc, "Process Mixed Event Data", false); + + void processMcRecMixedEventSc(SelCollisionsWithSc const& collisions, + TracksWithMc const& tracks, + aod::TracksWMc const&, + soa::Join const& candidates, + CandsLcData const&, + aod::McParticles const& mcParticles) + { + doMixEvent(collisions, tracks, candidates, &mcParticles); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecMixedEventSc, "Process Mixed Event McRec", false); + +void processMcRecMixedEventLc(SelCollisionsWithLc const& collisions, + CandsLcMcRecFiltered const& candidates, + TracksWithMc const& tracks, + aod::McParticles const& mcParticles) + { + doMixEvent(collisions, tracks, candidates, &mcParticles); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecMixedEventLc, "Process Mixed Event McRec", false) + + /// Lc-Hadron correlation pair builder - for Mc Gen-level analysis + void processMcGen(SelCollisionsWithLcMc::iterator const& mcCollision, + CandidatesLcMcGen const& mcParticles) +{ +int counterLcHadron = 0; +registry.fill(HIST("hMcEvtCount"), 0); + +BinningTypeMcGen corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true}; +poolBin = corrBinningMcGen.getBin(std::make_tuple(mcCollision.posZ(), mcCollision.multMCFT0A())); +registry.fill(HIST("hMultFT0AMcGen"), mcCollision.multMCFT0A()); + + +// find leading particle +if (correlateLcWithLeadingParticle) { +leadingIndex = findLeadingParticleMcGen(mcParticles, etaTrackMax.value, ptTrackMin.value); +} + +// Mc Gen level +for (const auto& particle : mcParticles) { +if (std::abs(particle.pdgCode()) != Pdg::kLambdaCPlus) { +continue; +} +if (!TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_3prong::DecayType::LcToPKPi)) { +continue; +} +double yL = RecoDecay::y(particle.pVector(), MassLambdaCPlus); +if (std::abs(yL) > yCandGenMax || particle.pt() < ptCandMin) { +continue; +} +registry.fill(HIST("hCandBin"), poolBin); +registry.fill(HIST("hPtCandMcGen"), particle.pt()); +registry.fill(HIST("hEtaMcGen"), particle.eta()); +registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); +registry.fill(HIST("hYMcGen"), yL); + +isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; +isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; +if (isPrompt) { +registry.fill(HIST("hPtCandMcGenPrompt"), particle.pt()); +} else if (isNonPrompt) { +registry.fill(HIST("hPtCandMcGenNonPrompt"), particle.pt()); +} + +// prompt and non-prompt division +std::vector listDaughters{}; +std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; +std::array prongsId; +listDaughters.clear(); +RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); +int counterDaughters = 0; +if (listDaughters.size() == nDaughters) { +for (const auto& dauIdx : listDaughters) { +auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); +counterDaughters += 1; +prongsId[counterDaughters - 1] = daughI.globalIndex(); +} +} +counterLcHadron++; +// Lc Hadron correlation dedicated section +// if it's a Lc particle, search for Hadron and evalutate correlations +registry.fill(HIST("hcountCandtriggersMcGen"), 0, particle.pt()); // to count trigger Lc for normalisation +for (const auto& particleAssoc : mcParticles) { +if (std::abs(particleAssoc.eta()) > etaTrackMax || particleAssoc.pt() < ptTrackMin || particleAssoc.pt() > ptTrackMax) { +continue; +} +if (particleAssoc.globalIndex() == prongsId[0] || particleAssoc.globalIndex() == prongsId[1] || particleAssoc.globalIndex() == prongsId[2]) { +if (!storeAutoCorrelationFlag) { +continue; +} +correlationStatus = true; +} + +if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { +continue; +} + +if (pidTrkApplied && (std::abs(particleAssoc.pdgCode()) != kProton)) +continue; // proton PID + +if (!particleAssoc.isPhysicalPrimary()) { +continue; +} + +if (correlateLcWithLeadingParticle) { +if (particleAssoc.globalIndex() != leadingIndex) { +continue; +} +} + +int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge +int8_t chargeAssoc = pdg->GetParticle(particleAssoc.pdgCode())->Charge(); // Retrieve charge + +int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, particleAssoc, true); +registry.fill(HIST("hPtParticleAssocMcGen"), particleAssoc.pt()); +entryCandHadronPair(getDeltaPhi(particleAssoc.phi(), particle.phi()), + particleAssoc.eta() - particle.eta(), + particle.pt() * chargeLc / std::abs(chargeLc), + particleAssoc.pt() * chargeAssoc / std::abs(chargeAssoc), + poolBin, + correlationStatus); +entryCandHadronPairY(particleAssoc.y() - yL); +entryCandHadronRecoInfo(MassLambdaCPlus, true); +entryCandHadronGenInfo(isPrompt, particleAssoc.isPhysicalPrimary(), trackOrigin); +} // end inner loop +} // end outer loop +registry.fill(HIST("hcountCandHadronPerEvent"), counterLcHadron); +registry.fill(HIST("hZvtx"), mcCollision.posZ()); +} +PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGen, "Process Mc Gen mode", false); + + + void processMcGenMixedEvent(SelCollisionsWithLcMc const& collisions, + CandidatesLcMcGen const& mcParticles) + { + BinningTypeMcGen corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true}; + auto tracksTuple = std::make_tuple(mcParticles, mcParticles); + Pair pairMcGen{corrBinningMcGen, numberEventsMixed, -1, collisions, tracksTuple, &cache}; + for (const auto& [c1, tracks1, c2, tracks2] : pairMcGen) { + poolBin = corrBinningMcGen.getBin(std::make_tuple(c1.posZ(), c1.multMCFT0A())); + for (const auto& [candidate, particleAssoc] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) { + if (std::abs(candidate.pdgCode()) != Pdg::kLambdaCPlus) { + continue; + } + double yL = RecoDecay::y(candidate.pVector(), MassLambdaCPlus); + if (std::abs(yL) > yCandGenMax || candidate.pt() < ptCandMin || candidate.pt() > ptCandMax) { + continue; + } + if (std::abs(particleAssoc.eta()) > etaTrackMax || particleAssoc.pt() < ptTrackMin || particleAssoc.pt() > ptTrackMax) { + continue; + } + if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particleAssoc.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { + continue; + } + if (!particleAssoc.isPhysicalPrimary()) { + continue; + } + if (pidTrkApplied && (std::abs(particleAssoc.pdgCode()) != kProton)) { + continue; // proton PID + } + int8_t chargeLc = pdg->GetParticle(candidate.pdgCode())->Charge(); // Retrieve charge + int8_t chargeAssoc = pdg->GetParticle(particleAssoc.pdgCode())->Charge(); // Retrieve charge + + int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, particleAssoc, true); + bool isPrompt = candidate.originMcGen() == RecoDecay::OriginType::Prompt; + entryCandHadronPair(getDeltaPhi(particleAssoc.phi(), candidate.phi()), + particleAssoc.eta() - candidate.eta(), + candidate.pt() * chargeLc / std::abs(chargeLc), + particleAssoc.pt() * chargeAssoc / std::abs(chargeAssoc), + poolBin, + correlationStatus); + entryCandHadronPairY(particleAssoc.y() - yL); + entryCandHadronRecoInfo(MassLambdaCPlus, true); + entryCandHadronGenInfo(isPrompt, particleAssoc.isPhysicalPrimary(), trackOrigin); + } + } + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGenMixedEvent, "Process Mixed Event McGen", false); +}; + +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc), + adaptAnalysisTask(cfgc)}; +} From 73b61cedb827697f8376aa2e41d6b882d83cf4f3 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 27 May 2025 22:12:27 +0200 Subject: [PATCH 02/35] Update CMakeLists for Sc correlator --- PWGHF/HFC/TableProducer/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/PWGHF/HFC/TableProducer/CMakeLists.txt b/PWGHF/HFC/TableProducer/CMakeLists.txt index 56b01bcd412..99f2c4fb152 100644 --- a/PWGHF/HFC/TableProducer/CMakeLists.txt +++ b/PWGHF/HFC/TableProducer/CMakeLists.txt @@ -64,6 +64,11 @@ o2physics_add_dpl_workflow(correlator-lc-hadrons PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(correlator-lc-sc-hadrons + SOURCES correlatorLcScHadrons.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(femto-dream-producer SOURCES femtoDreamProducer.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::EventFilteringUtils O2Physics::MLCore From 04ad2a30f06075890a4f4b3b30f9e06a4642979e Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 27 May 2025 20:16:45 +0000 Subject: [PATCH 03/35] Please consider the following formatting changes --- .../TableProducer/correlatorLcScHadrons.cxx | 918 +++++++++--------- 1 file changed, 457 insertions(+), 461 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 1514d05c058..8a50f6517b9 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -174,7 +174,6 @@ struct HfCorrelatorLcScHadrons { Produces entryPairCandCharge; Produces entryCandCharge; - Configurable selectionFlagLc{"selectionFlagLc", 1, "Selection Flag for Lc"}; Configurable numberEventsMixed{"numberEventsMixed", 5, "number of events mixed in ME process"}; Configurable applyEfficiency{"applyEfficiency", 1, "Flag for applying Lc efficiency weights"}; @@ -229,10 +228,10 @@ struct HfCorrelatorLcScHadrons { using SelCollisionsWithSc = soa::Join; using SelCollisionsWithLc = soa::Filtered>; using SelCollisionsWithLcMc = soa::Filtered>; // collisionFilter applied - + using CandsLcData = soa::Join; using CandsLcDataFiltered = soa::Filtered; - + // Event Mixing for the MCRec Mode using CandsLcMcRec = soa::Join; using CandsLcMcRecFiltered = soa::Filtered; @@ -335,11 +334,11 @@ struct HfCorrelatorLcScHadrons { registry.add("hMultFT0AMcGen", "Lc,Hadron multiplicity FT0A - MC Gen", {HistType::kTH1F, {axisMultiplicity}}); corrBinning = {{binsZVtx, binsMultiplicity}, true}; - } template - void fillMlOutput(mlProbType& mlProb, std::vector& outputMl) { + void fillMlOutput(mlProbType& mlProb, std::vector& outputMl) + { for (unsigned int iclass = 0; iclass < classMl->size(); iclass++) { outputMl[iclass] = mlProb[classMl->at(iclass)]; } @@ -349,19 +348,19 @@ struct HfCorrelatorLcScHadrons { double estimateY(candtype& cand) { double y = -999.; - if constexpr (isCandSc){ + if constexpr (isCandSc) { int8_t chargeCand = cand.charge(); - if (chargeCand == 0) { - y = hfHelper.ySc0(cand); - } else { - y = hfHelper.yScPlusPlus(cand); - } + if (chargeCand == 0) { + y = hfHelper.ySc0(cand); + } else { + y = hfHelper.yScPlusPlus(cand); + } } else { y = hfHelper.yLc(cand); } - return y; + return y; } template @@ -379,40 +378,41 @@ struct HfCorrelatorLcScHadrons { return channel; /// 0: none; 1: pK-π+ only; 2: π+K-p only; 3: both possible } - template - void calculateTrkEff(t1& trackPos1, t2& trackPos2, mcPart& mcParticles){ - // genrated tracks - decltype(trackPos1.template mcParticle_as()) mctrk{}; - if (trackPos1.has_mcParticle()) { // ambiguous tracks should be small - mctrk = trackPos1.template mcParticle_as(); - } else if (trackPos2.has_mcParticle()) { - mctrk = trackPos2.template mcParticle_as(); - } else { - return; - } - auto gentracks = mcParticles.sliceBy(perTrueCollision, mctrk.mcCollisionId()); - for (const auto& track : gentracks) { - if (std::abs(track.eta()) > etaTrackMax || track.pt() < ptTrackMin || track.pt() > ptTrackMax) { - continue; - } - if ((std::abs(track.pdgCode()) != kElectron) && (std::abs(track.pdgCode()) != kMuonMinus) && (std::abs(track.pdgCode()) != kPiPlus) && (std::abs(track.pdgCode()) != kKPlus) && (std::abs(track.pdgCode()) != kProton)) { - continue; - } - - if (pidTrkApplied && (std::abs(track.pdgCode()) != kProton)) - continue; // proton PID - - if (!track.isPhysicalPrimary()) { - continue; - } - - auto motherTrkGen = mcParticles.iteratorAt(track.mothersIds()[0]); - if (std::abs(motherTrkGen.pdgCode()) == kLambdaCPlus) - continue; - - auto chargeTrack = pdg->GetParticle(track.pdgCode())->Charge(); // Retrieve charge - registry.fill(HIST("hPtTracksVsSignGen"), track.pt(), chargeTrack / (2 * std::abs(chargeTrack))); - } + template + void calculateTrkEff(t1& trackPos1, t2& trackPos2, mcPart& mcParticles) + { + // genrated tracks + decltype(trackPos1.template mcParticle_as()) mctrk{}; + if (trackPos1.has_mcParticle()) { // ambiguous tracks should be small + mctrk = trackPos1.template mcParticle_as(); + } else if (trackPos2.has_mcParticle()) { + mctrk = trackPos2.template mcParticle_as(); + } else { + return; + } + auto gentracks = mcParticles.sliceBy(perTrueCollision, mctrk.mcCollisionId()); + for (const auto& track : gentracks) { + if (std::abs(track.eta()) > etaTrackMax || track.pt() < ptTrackMin || track.pt() > ptTrackMax) { + continue; + } + if ((std::abs(track.pdgCode()) != kElectron) && (std::abs(track.pdgCode()) != kMuonMinus) && (std::abs(track.pdgCode()) != kPiPlus) && (std::abs(track.pdgCode()) != kKPlus) && (std::abs(track.pdgCode()) != kProton)) { + continue; + } + + if (pidTrkApplied && (std::abs(track.pdgCode()) != kProton)) + continue; // proton PID + + if (!track.isPhysicalPrimary()) { + continue; + } + + auto motherTrkGen = mcParticles.iteratorAt(track.mothersIds()[0]); + if (std::abs(motherTrkGen.pdgCode()) == kLambdaCPlus) + continue; + + auto chargeTrack = pdg->GetParticle(track.pdgCode())->Charge(); // Retrieve charge + registry.fill(HIST("hPtTracksVsSignGen"), track.pt(), chargeTrack / (2 * std::abs(chargeTrack))); + } } template void fillCorrelationTable(bool trkPidFill, tracktype& trk, candtype& cand, std::vector outMl, int binPool, int8_t correlStatus, double candY, int signCand, mcPart& mcParticles) @@ -421,40 +421,41 @@ struct HfCorrelatorLcScHadrons { int trackOrigin = -1; entryCandHadronPair(getDeltaPhi(trk.phi(), cand.phi()), - trk.eta() - cand.eta(), - cand.pt(), - trk.pt() * trk.sign(), - binPool, - correlStatus); -entryCandHadronPairY(trk.y() - candY); -entryCandHadronMlInfo(outMl[0], outMl[1]); -entryTrackRecoInfo(trk.dcaXY(), trk.dcaZ(), trk.tpcNClsCrossedRows()); -entryPairCandCharge(signCand); -if (trkPidFill) { -entryCandHadronPairTrkPID(trk.tpcNSigmaPr(), trk.tpcNSigmaKa(), trk.tpcNSigmaPi(), trk.tofNSigmaPr(), trk.tofNSigmaKa(), trk.tofNSigmaPi()); -} -if constexpr (isMcRec){ - if (trk.has_mcParticle()) { - auto mcParticle = trk.template mcParticle_as(); - isPhysicalPrimary = mcParticle.isPhysicalPrimary(); - trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, mcParticle, true); - entryCandHadronGenInfo(isPrompt, isPhysicalPrimary, trackOrigin); - } else { - entryCandHadronGenInfo(isPrompt, false, 0); - registry.fill(HIST("hFakeTracksMcRec"), trk.pt()); - } - registry.fill(HIST("hPtParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); - if (isPhysicalPrimary) { - registry.fill(HIST("hPtPrimaryParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); - } -} + trk.eta() - cand.eta(), + cand.pt(), + trk.pt() * trk.sign(), + binPool, + correlStatus); + entryCandHadronPairY(trk.y() - candY); + entryCandHadronMlInfo(outMl[0], outMl[1]); + entryTrackRecoInfo(trk.dcaXY(), trk.dcaZ(), trk.tpcNClsCrossedRows()); + entryPairCandCharge(signCand); + if (trkPidFill) { + entryCandHadronPairTrkPID(trk.tpcNSigmaPr(), trk.tpcNSigmaKa(), trk.tpcNSigmaPi(), trk.tofNSigmaPr(), trk.tofNSigmaKa(), trk.tofNSigmaPi()); + } + if constexpr (isMcRec) { + if (trk.has_mcParticle()) { + auto mcParticle = trk.template mcParticle_as(); + isPhysicalPrimary = mcParticle.isPhysicalPrimary(); + trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, mcParticle, true); + entryCandHadronGenInfo(isPrompt, isPhysicalPrimary, trackOrigin); + } else { + entryCandHadronGenInfo(isPrompt, false, 0); + registry.fill(HIST("hFakeTracksMcRec"), trk.pt()); + } + registry.fill(HIST("hPtParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); + if (isPhysicalPrimary) { + registry.fill(HIST("hPtPrimaryParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); + } + } } template void doSameEvent(CollisionType const& collision, TrackType const& tracks, CandType const& candidates, - aod::McParticles const* mcParticles = nullptr) { + aod::McParticles const* mcParticles = nullptr) + { int nTracks = 0; int64_t timeStamp = 0; @@ -464,7 +465,7 @@ if constexpr (isMcRec){ if (candidates.size() == 0) { return; } - + if (eventFractionToAnalyze > 0) { if (rnd->Uniform(0, 1) > eventFractionToAnalyze) { skipMixedEventTableFilling = true; @@ -475,10 +476,10 @@ if constexpr (isMcRec){ timeStamp = collision.template bc_as().timestamp(); } - poolBin = corrBinning.getBin(std::make_tuple(collision.posZ(), multiplicityFT0M)); - if (correlateLcWithLeadingParticle) { - leadingIndex = findLeadingParticle(tracks, etaTrackMax.value); - } + poolBin = corrBinning.getBin(std::make_tuple(collision.posZ(), multiplicityFT0M)); + if (correlateLcWithLeadingParticle) { + leadingIndex = findLeadingParticle(tracks, etaTrackMax.value); + } // Count good tracks if (collision.numContrib() > 1) { @@ -489,15 +490,15 @@ if constexpr (isMcRec){ nTracks++; } } - + registry.fill(HIST("hMultiplicityPreSelection"), nTracks); if (nTracks < multMin || nTracks > multMax) { return; } registry.fill(HIST("hMultiplicity"), nTracks); - + int countCand = 1; - + for (const auto& candidate : candidates) { int8_t chargeCand = 3; @@ -531,41 +532,41 @@ if constexpr (isMcRec){ efficiencyWeightCand = 1. / efficiencyLc->at(o2::analysis::findBin(binsPtEfficiencyLc, ptCand)); } - if constexpr (isMcRec){ + if constexpr (isMcRec) { isPrompt = candidate.originMcRec() == RecoDecay::OriginType::Prompt; isNonPrompt = candidate.originMcRec() == RecoDecay::OriginType::NonPrompt; } - + if constexpr (isCandSc) { chargeCand = candidate.charge(); const auto& candidateLc = candidate.template prongLc_as(); ptCandLc = candidateLc.pt(); selLcPKPi = (candidateLc.isSelLcToPKPi() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPKPiFromPDG()); selLcPiKP = (candidateLc.isSelLcToPiKP() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPiKPFromPDG()); - if(selLcPKPi){ - const auto& probs = candidateLc.mlProbLcToPKPi(); - fillMlOutput(probs,outputMlPKPi); - massCandPKPi = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); + if (selLcPKPi) { + const auto& probs = candidateLc.mlProbLcToPKPi(); + fillMlOutput(probs, outputMlPKPi); + massCandPKPi = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); } - if(selLcPiKP){ + if (selLcPiKP) { const auto& probs = candidateLc.mlProbLcToPiKP(); - fillMlOutput(probs,outputMlPiKP); + fillMlOutput(probs, outputMlPiKP); massCandPiKP = hfHelper.invMassScRecoLcToPiKP(candidate, candidateLc); } if constexpr (isMcRec) { - //isSignal = - // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || - // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + // isSignal = + // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || + // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); isSignal = - (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || - (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || + (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); - auto trackPos1 = candidateLc.template prong0_as(); - auto trackPos2 = candidateLc.template prong2_as(); - if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand)) { - calculateTrkEff(trackPos1, trackPos2, *mcParticles); - } - registry.fill(HIST("hPtProng1"), candidate.template prong1_as().pt()); + auto trackPos1 = candidateLc.template prong0_as(); + auto trackPos2 = candidateLc.template prong2_as(); + if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand)) { + calculateTrkEff(trackPos1, trackPos2, *mcParticles); + } + registry.fill(HIST("hPtProng1"), candidate.template prong1_as().pt()); } else { registry.fill(HIST("hPtProng1"), candidate.prong1().pt()); } @@ -573,87 +574,88 @@ if constexpr (isMcRec){ } else { selLcPKPi = candidate.isSelLcToPKPi() >= selectionFlagLc; selLcPiKP = candidate.isSelLcToPiKP() >= selectionFlagLc; - if(selLcPKPi){ + if (selLcPKPi) { const auto& probs = candidate.mlProbLcToPKPi(); - fillMlOutput(probs,outputMlPKPi); + fillMlOutput(probs, outputMlPKPi); massCandPKPi = hfHelper.invMassLcToPKPi(candidate); } - if(selLcPiKP){ + if (selLcPiKP) { const auto& probs = candidate.mlProbLcToPiKP(); - fillMlOutput(probs,outputMlPiKP); - massCandPiKP = hfHelper.invMassLcToPiKP(candidate); - } + fillMlOutput(probs, outputMlPiKP); + massCandPiKP = hfHelper.invMassLcToPiKP(candidate); + } auto trackPos1 = candidate.template prong0_as(); auto trackPos2 = candidate.template prong2_as(); chargeCand = trackPos1.sign(); - if constexpr (isMcRec){ - isSignal = TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi); - if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand)) { - calculateTrkEff(trackPos1, trackPos2, *mcParticles); + if constexpr (isMcRec) { + isSignal = TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi); + if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand)) { + calculateTrkEff(trackPos1, trackPos2, *mcParticles); + } } + registry.fill(HIST("hPtProng0"), candidate.ptProng0()); + registry.fill(HIST("hPtProng1"), candidate.ptProng1()); + registry.fill(HIST("hPtProng2"), candidate.ptProng2()); } - registry.fill(HIST("hPtProng0"), candidate.ptProng0()); - registry.fill(HIST("hPtProng1"), candidate.ptProng1()); - registry.fill(HIST("hPtProng2"), candidate.ptProng2()); + + if (isSignal) { + registry.fill(HIST("hPtCandSig"), ptCand); + registry.fill(HIST("hEtaSig"), ptCand); + registry.fill(HIST("hPhiSig"), phiCand); + registry.fill(HIST("hYSig"), yCand); } - if (isSignal){ - registry.fill(HIST("hPtCandSig"), ptCand); - registry.fill(HIST("hEtaSig"), ptCand); - registry.fill(HIST("hPhiSig"), phiCand); - registry.fill(HIST("hYSig"), yCand); - } + if (selLcPKPi) { + registry.fill(HIST("hMassLcVsPt"), massCandPKPi, ptCand, efficiencyWeightCand); + registry.fill(HIST("hMassLcData"), massCandPKPi, efficiencyWeightCand); + registry.fill(HIST("hSelectionStatusLcToPKPi"), selLcPKPi); + if (isPrompt) { + registry.fill(HIST("hPtCandSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, multiplicityFT0M); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, multiplicityFT0M); + } - if (selLcPKPi) { - registry.fill(HIST("hMassLcVsPt"), massCandPKPi, ptCand, efficiencyWeightCand); - registry.fill(HIST("hMassLcData"), massCandPKPi, efficiencyWeightCand); - registry.fill(HIST("hSelectionStatusLcToPKPi"), selLcPKPi); - if (isPrompt) { - registry.fill(HIST("hPtCandSigPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, multiplicityFT0M); - } else if (isNonPrompt) { - registry.fill(HIST("hPtCandSigNonPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, multiplicityFT0M); - } - - entryCandCandRecoInfo(massCandPKPi, ptCand, outputMlPKPi[0], outputMlPKPi[1]); - entryCandCandGenInfo(isPrompt); - if (!skipMixedEventTableFilling) { - entryCand(candidate.phi(),etaCand, ptCand, massCandPKPi, poolBin, gCollisionId, timeStamp); + entryCandCandRecoInfo(massCandPKPi, ptCand, outputMlPKPi[0], outputMlPKPi[1]); + entryCandCandGenInfo(isPrompt); + if (!skipMixedEventTableFilling) { + entryCand(candidate.phi(), etaCand, ptCand, massCandPKPi, poolBin, gCollisionId, timeStamp); entryCandCharge(chargeCand); - } } - - if (selLcPiKP) { - registry.fill(HIST("hMassLcVsPt"), massCandPiKP, ptCand, efficiencyWeightCand); - registry.fill(HIST("hMassLcData"), massCandPiKP, efficiencyWeightCand); - registry.fill(HIST("hSelectionStatusLcToPiKP"), selLcPiKP); - if (isPrompt) { - registry.fill(HIST("hPtCandSigPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, multiplicityFT0M); - } else if (isNonPrompt) { - registry.fill(HIST("hPtCandSigNonPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, multiplicityFT0M); - } - entryCandCandRecoInfo(massCandPiKP, ptCand, outputMlPiKP[0], outputMlPiKP[1]); - entryCandCandGenInfo(isPrompt); - if (!skipMixedEventTableFilling) { - entryCand(candidate.phi(), etaCand, ptCand, massCandPiKP, poolBin, gCollisionId, timeStamp); - entryCandCharge(chargeCand); - } - } + } - registry.fill(HIST("hCandBin"), poolBin); + if (selLcPiKP) { + registry.fill(HIST("hMassLcVsPt"), massCandPiKP, ptCand, efficiencyWeightCand); + registry.fill(HIST("hMassLcData"), massCandPiKP, efficiencyWeightCand); + registry.fill(HIST("hSelectionStatusLcToPiKP"), selLcPiKP); + if (isPrompt) { + registry.fill(HIST("hPtCandSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, multiplicityFT0M); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, multiplicityFT0M); + } + entryCandCandRecoInfo(massCandPiKP, ptCand, outputMlPiKP[0], outputMlPiKP[1]); + entryCandCandGenInfo(isPrompt); + if (!skipMixedEventTableFilling) { + entryCand(candidate.phi(), etaCand, ptCand, massCandPiKP, poolBin, gCollisionId, timeStamp); + entryCandCharge(chargeCand); + } + } + + registry.fill(HIST("hCandBin"), poolBin); // Correlation with hadrons for (const auto& track : tracks) { // Remove Lc daughters by checking track indices - if constexpr (!isCandSc){ - if ((candidate.prong0Id() == track.globalIndex()) || (candidate.prong1Id() == track.globalIndex()) || (candidate.prong2Id() == track.globalIndex())) { - if (!storeAutoCorrelationFlag) { - continue; + if constexpr (!isCandSc) { + if ((candidate.prong0Id() == track.globalIndex()) || (candidate.prong1Id() == track.globalIndex()) || (candidate.prong2Id() == track.globalIndex())) { + if (!storeAutoCorrelationFlag) { + continue; + } + correlationStatus = true; } - correlationStatus = true; - }} else { + } else { const auto& candidateLc = candidate.template prongLc_as(); if ((candidateLc.prong0Id() == track.globalIndex()) || (candidateLc.prong1Id() == track.globalIndex()) || (candidateLc.prong2Id() == track.globalIndex()) || (candidate.prong1Id() == track.globalIndex())) { if (!storeAutoCorrelationFlag) { @@ -674,32 +676,31 @@ if constexpr (isMcRec){ continue; } } - if constexpr (isMcRec){ - if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand) && track.has_mcParticle()) { - auto mcParticle = track.template mcParticle_as(); - if (!mcParticle.isPhysicalPrimary() && isRecTrkPhyPrimary) - continue; - - auto motherTrk = mcParticles->iteratorAt(mcParticle.mothersIds()[0]); - if (std::abs(motherTrk.pdgCode()) == kLambdaCPlus) - continue; + if constexpr (isMcRec) { + if (calTrkEff && countCand == 1 && (isSignal || !calEffEventWithCand) && track.has_mcParticle()) { + auto mcParticle = track.template mcParticle_as(); + if (!mcParticle.isPhysicalPrimary() && isRecTrkPhyPrimary) + continue; + auto motherTrk = mcParticles->iteratorAt(mcParticle.mothersIds()[0]); + if (std::abs(motherTrk.pdgCode()) == kLambdaCPlus) + continue; - registry.fill(HIST("hPtTracksVsSignRec"), track.pt(), track.sign() / 2.); - if (std::abs(mcParticle.pdgCode()) == kProton) - registry.fill(HIST("hPtTracksVsSignRecTrue"), track.pt(), track.sign() / 2.); + registry.fill(HIST("hPtTracksVsSignRec"), track.pt(), track.sign() / 2.); + if (std::abs(mcParticle.pdgCode()) == kProton) + registry.fill(HIST("hPtTracksVsSignRecTrue"), track.pt(), track.sign() / 2.); + } } - } if (selLcPKPi) { - fillCorrelationTable(fillTrkPID, track, candidate, outputMlPKPi, poolBin, correlationStatus, yCand, chargeCand,*mcParticles); + fillCorrelationTable(fillTrkPID, track, candidate, outputMlPKPi, poolBin, correlationStatus, yCand, chargeCand, *mcParticles); entryCandHadronRecoInfo(massCandPKPi, false); } if (selLcPiKP) { fillCorrelationTable(fillTrkPID, track, candidate, outputMlPiKP, poolBin, correlationStatus, yCand, chargeCand, *mcParticles); entryCandHadronRecoInfo(massCandPiKP, false); } - + if (countCand == 1) { if (!skipMixedEventTableFilling) { entryHadron(track.phi(), track.eta(), track.pt() * track.sign(), poolBin, gCollisionId, timeStamp); @@ -714,318 +715,313 @@ if constexpr (isMcRec){ } // end outer Lc loop registry.fill(HIST("hZvtx"), collision.posZ()); registry.fill(HIST("hMultFT0M"), multiplicityFT0M); - } template void doMixEvent(CollisionType const& collisions, - TrackType const& tracks, - CandType const& candidates, - aod::McParticles const* mcParticles = nullptr) { - - if (candidates.size() == 0){ - return; - } - - double yCand = -999.; - double ptCand = -999.; - int8_t chargeCand = 3; - double massCandPKPi = -999.0; - double massCandPiKP = -999.0; - bool selLcPKPi = false; - bool selLcPiKP = false; - - auto tracksTuple = std::make_tuple(candidates, tracks); - Pair pairData{corrBinning, numberEventsMixed, -1, collisions, tracksTuple, &cache}; - - for (const auto& [c1, tracks1, c2, tracks2] : pairData) { - poolBin = corrBinning.getBin(std::make_tuple(c2.posZ(), c2.multFT0M())); - poolBinLc = corrBinning.getBin(std::make_tuple(c1.posZ(), c1.multFT0M())); - registry.fill(HIST("hMultFT0M"), c1.multFT0M()); - registry.fill(HIST("hZvtx"), c1.posZ()); - registry.fill(HIST("hTracksPoolBin"), poolBin); - registry.fill(HIST("hLcPoolBin"), poolBinLc); - for (const auto& [candidate, assocParticle] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) { - - yCand = estimateY(candidate); - ptCand = candidate.pt(); - if constexpr (isMcRec){ - isPrompt = candidate.originMcRec() == RecoDecay::OriginType::Prompt; - isNonPrompt = candidate.originMcRec() == RecoDecay::OriginType::NonPrompt; - } - - if constexpr (isCandSc) { - const auto& candidateLc = candidate.template prongLc_as(); - chargeCand = candidate.charge(); - selLcPKPi = (candidateLc.isSelLcToPKPi() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPKPiFromPDG()); - selLcPiKP = (candidateLc.isSelLcToPiKP() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPiKPFromPDG()); - if (selLcPKPi) { - const auto& probs = candidateLc.mlProbLcToPKPi(); - fillMlOutput(probs,outputMlPKPi); - massCandPKPi = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); - } - if (selLcPiKP){ - const auto& probs = candidateLc.mlProbLcToPiKP(); - fillMlOutput(probs,outputMlPiKP); - massCandPiKP = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); - } - if constexpr (isMcRec) { - isSignal = - (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || - (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); - } - } else { - selLcPKPi = candidate.isSelLcToPKPi() >= selectionFlagLc; - selLcPiKP = candidate.isSelLcToPiKP() >= selectionFlagLc; - if (selLcPKPi) { - const auto& probs = candidate.mlProbLcToPKPi(); - fillMlOutput(probs,outputMlPKPi); - massCandPKPi = hfHelper.invMassLcToPKPi(candidate); - } - if (selLcPiKP){ - const auto& probs = candidate.mlProbLcToPiKP(); - fillMlOutput(probs,outputMlPiKP); - massCandPiKP = hfHelper.invMassLcToPiKP(candidate); - } - auto trackPos1 = candidate.template prong0_as(); - chargeCand = trackPos1.sign(); - if constexpr (isMcRec){ - isSignal = TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi); - } - } - - if (!assocParticle.isGlobalTrackWoDCA() || std::abs(yCand) > yCandMax) { - continue; - } - - if (pidTrkApplied) { - if (!passPIDSelection(assocParticle, trkPIDspecies, pidTPCMax, pidTOFMax, tofPIDThreshold, forceTOF)) - continue; - } - - if (selLcPKPi){ - fillCorrelationTable(fillTrkPID, assocParticle, candidate, outputMlPKPi, poolBin, correlationStatus, yCand, chargeCand,*mcParticles); - entryCandHadronRecoInfo(massCandPKPi, false); - - if (isPrompt) { - registry.fill(HIST("hPtCandMcRecSigPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, 0); - } else if (isNonPrompt) { - registry.fill(HIST("hPtCandMcRecSigNonPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, 0); - } - } - - if (selLcPiKP){ - fillCorrelationTable(fillTrkPID, assocParticle, candidate, outputMlPiKP, poolBin, correlationStatus, yCand, chargeCand, *mcParticles); - entryCandHadronRecoInfo(massCandPiKP, false); - - if (isPrompt) { - registry.fill(HIST("hPtCandMcRecSigPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, 0); - } else if (isNonPrompt) { - registry.fill(HIST("hPtCandMcRecSigNonPrompt"), ptCand); - registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, 0); - } - } - - } - } - } - - //} - - /// Lc-hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via MC truth) - void processDataLc(SelCollisionsWithLc::iterator const& collision, - TracksData const& tracks, - CandsLcDataFiltered const& candidates, aod::BCsWithTimestamps const&) - { - doSameEvent(collision, tracks, candidates); - } - PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataLc, "Process data", true); - - -void processDataSc(SelCollisionsWithSc::iterator const& collision, - TracksData const& tracks, - aod::Tracks const&, - aod::HfCandSc const& candidates, CandsLcData const&, - aod::BCsWithTimestamps const&) // MUST be last among index-compatible -{ - doSameEvent(collision, tracks, candidates); -} -PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataSc, "Process data Sc", false); + TrackType const& tracks, + CandType const& candidates, + aod::McParticles const* mcParticles = nullptr) + { + + if (candidates.size() == 0) { + return; + } + + double yCand = -999.; + double ptCand = -999.; + int8_t chargeCand = 3; + double massCandPKPi = -999.0; + double massCandPiKP = -999.0; + bool selLcPKPi = false; + bool selLcPiKP = false; + + auto tracksTuple = std::make_tuple(candidates, tracks); + Pair pairData{corrBinning, numberEventsMixed, -1, collisions, tracksTuple, &cache}; + + for (const auto& [c1, tracks1, c2, tracks2] : pairData) { + poolBin = corrBinning.getBin(std::make_tuple(c2.posZ(), c2.multFT0M())); + poolBinLc = corrBinning.getBin(std::make_tuple(c1.posZ(), c1.multFT0M())); + registry.fill(HIST("hMultFT0M"), c1.multFT0M()); + registry.fill(HIST("hZvtx"), c1.posZ()); + registry.fill(HIST("hTracksPoolBin"), poolBin); + registry.fill(HIST("hLcPoolBin"), poolBinLc); + for (const auto& [candidate, assocParticle] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) { + + yCand = estimateY(candidate); + ptCand = candidate.pt(); + if constexpr (isMcRec) { + isPrompt = candidate.originMcRec() == RecoDecay::OriginType::Prompt; + isNonPrompt = candidate.originMcRec() == RecoDecay::OriginType::NonPrompt; + } + + if constexpr (isCandSc) { + const auto& candidateLc = candidate.template prongLc_as(); + chargeCand = candidate.charge(); + selLcPKPi = (candidateLc.isSelLcToPKPi() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPKPiFromPDG()); + selLcPiKP = (candidateLc.isSelLcToPiKP() >= selectionFlagLc) && (candidate.statusSpreadLcMinvPiKPFromPDG()); + if (selLcPKPi) { + const auto& probs = candidateLc.mlProbLcToPKPi(); + fillMlOutput(probs, outputMlPKPi); + massCandPKPi = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); + } + if (selLcPiKP) { + const auto& probs = candidateLc.mlProbLcToPiKP(); + fillMlOutput(probs, outputMlPiKP); + massCandPiKP = hfHelper.invMassScRecoLcToPKPi(candidate, candidateLc); + } + if constexpr (isMcRec) { + isSignal = + (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || + (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + } + } else { + selLcPKPi = candidate.isSelLcToPKPi() >= selectionFlagLc; + selLcPiKP = candidate.isSelLcToPiKP() >= selectionFlagLc; + if (selLcPKPi) { + const auto& probs = candidate.mlProbLcToPKPi(); + fillMlOutput(probs, outputMlPKPi); + massCandPKPi = hfHelper.invMassLcToPKPi(candidate); + } + if (selLcPiKP) { + const auto& probs = candidate.mlProbLcToPiKP(); + fillMlOutput(probs, outputMlPiKP); + massCandPiKP = hfHelper.invMassLcToPiKP(candidate); + } + auto trackPos1 = candidate.template prong0_as(); + chargeCand = trackPos1.sign(); + if constexpr (isMcRec) { + isSignal = TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_3prong::DecayType::LcToPKPi); + } + } + + if (!assocParticle.isGlobalTrackWoDCA() || std::abs(yCand) > yCandMax) { + continue; + } + + if (pidTrkApplied) { + if (!passPIDSelection(assocParticle, trkPIDspecies, pidTPCMax, pidTOFMax, tofPIDThreshold, forceTOF)) + continue; + } + + if (selLcPKPi) { + fillCorrelationTable(fillTrkPID, assocParticle, candidate, outputMlPKPi, poolBin, correlationStatus, yCand, chargeCand, *mcParticles); + entryCandHadronRecoInfo(massCandPKPi, false); + + if (isPrompt) { + registry.fill(HIST("hPtCandMcRecSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, 0); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandMcRecSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, 0); + } + } + + if (selLcPiKP) { + fillCorrelationTable(fillTrkPID, assocParticle, candidate, outputMlPiKP, poolBin, correlationStatus, yCand, chargeCand, *mcParticles); + entryCandHadronRecoInfo(massCandPiKP, false); + + if (isPrompt) { + registry.fill(HIST("hPtCandMcRecSigPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecPrompt"), ptCand, 0); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandMcRecSigNonPrompt"), ptCand); + registry.fill(HIST("hPtVsMultiplicityMcRecNonPrompt"), ptCand, 0); + } + } + } + } + } + + //} + + /// Lc-hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via MC truth) + void processDataLc(SelCollisionsWithLc::iterator const& collision, + TracksData const& tracks, + CandsLcDataFiltered const& candidates, aod::BCsWithTimestamps const&) + { + doSameEvent(collision, tracks, candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataLc, "Process data", true); + + void processDataSc(SelCollisionsWithSc::iterator const& collision, + TracksData const& tracks, + aod::Tracks const&, + aod::HfCandSc const& candidates, CandsLcData const&, + aod::BCsWithTimestamps const&) // MUST be last among index-compatible + { + doSameEvent(collision, tracks, candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataSc, "Process data Sc", false); /// Lc-Hadron correlation process starts for McRec void processMcRecLc(SelCollisionsWithLc::iterator const& collision, - TracksWithMc const& tracks, - CandsLcMcRecFiltered const& candidates, - aod::McParticles const& mcParticles) + TracksWithMc const& tracks, + CandsLcMcRecFiltered const& candidates, + aod::McParticles const& mcParticles) { - doSameEvent(collision, tracks, candidates, &mcParticles); + doSameEvent(collision, tracks, candidates, &mcParticles); } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecLc, "Process Mc Reco mode", false); - /// Lc-Hadron correlation process starts for McRec - void processMcRecSc(SelCollisionsWithSc::iterator const& collision, - TracksWithMc const& tracks, - aod::TracksWMc const&, - soa::Join const& candidates, - CandsLcData const&, - aod::McParticles const& mcParticles) -{ -doSameEvent(collision, tracks, candidates, &mcParticles); -} -PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecSc, "Process Mc Reco mode", false); + /// Lc-Hadron correlation process starts for McRec + void processMcRecSc(SelCollisionsWithSc::iterator const& collision, + TracksWithMc const& tracks, + aod::TracksWMc const&, + soa::Join const& candidates, + CandsLcData const&, + aod::McParticles const& mcParticles) + { + doSameEvent(collision, tracks, candidates, &mcParticles); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecSc, "Process Mc Reco mode", false); void processDataMixedEventSc(SelCollisionsWithSc const& collisions, - TracksData const& tracks, - aod::Tracks const&, - aod::HfCandSc const& candidates, CandsLcData const&) - { - doMixEvent(collisions, tracks, candidates); - } - PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataMixedEventSc, "Process Mixed Event Data", false); + TracksData const& tracks, + aod::Tracks const&, + aod::HfCandSc const& candidates, CandsLcData const&) + { + doMixEvent(collisions, tracks, candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataMixedEventSc, "Process Mixed Event Data", false); void processDataMixedEventLc(SelCollisionsWithLc const& collisions, - CandsLcDataFiltered const& candidates, - TracksData const& tracks) + CandsLcDataFiltered const& candidates, + TracksData const& tracks) { - doMixEvent(collisions, tracks, candidates); - + doMixEvent(collisions, tracks, candidates); } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataMixedEventLc, "Process Mixed Event Data", false); - void processMcRecMixedEventSc(SelCollisionsWithSc const& collisions, - TracksWithMc const& tracks, - aod::TracksWMc const&, - soa::Join const& candidates, - CandsLcData const&, - aod::McParticles const& mcParticles) - { - doMixEvent(collisions, tracks, candidates, &mcParticles); - } - PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecMixedEventSc, "Process Mixed Event McRec", false); - -void processMcRecMixedEventLc(SelCollisionsWithLc const& collisions, - CandsLcMcRecFiltered const& candidates, - TracksWithMc const& tracks, - aod::McParticles const& mcParticles) + void processMcRecMixedEventSc(SelCollisionsWithSc const& collisions, + TracksWithMc const& tracks, + aod::TracksWMc const&, + soa::Join const& candidates, + CandsLcData const&, + aod::McParticles const& mcParticles) { - doMixEvent(collisions, tracks, candidates, &mcParticles); + doMixEvent(collisions, tracks, candidates, &mcParticles); } - PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecMixedEventLc, "Process Mixed Event McRec", false) + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecMixedEventSc, "Process Mixed Event McRec", false); - /// Lc-Hadron correlation pair builder - for Mc Gen-level analysis - void processMcGen(SelCollisionsWithLcMc::iterator const& mcCollision, - CandidatesLcMcGen const& mcParticles) -{ -int counterLcHadron = 0; -registry.fill(HIST("hMcEvtCount"), 0); + void processMcRecMixedEventLc(SelCollisionsWithLc const& collisions, + CandsLcMcRecFiltered const& candidates, + TracksWithMc const& tracks, + aod::McParticles const& mcParticles) + { + doMixEvent(collisions, tracks, candidates, &mcParticles); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecMixedEventLc, "Process Mixed Event McRec", false) -BinningTypeMcGen corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true}; -poolBin = corrBinningMcGen.getBin(std::make_tuple(mcCollision.posZ(), mcCollision.multMCFT0A())); -registry.fill(HIST("hMultFT0AMcGen"), mcCollision.multMCFT0A()); + /// Lc-Hadron correlation pair builder - for Mc Gen-level analysis + void processMcGen(SelCollisionsWithLcMc::iterator const& mcCollision, + CandidatesLcMcGen const& mcParticles) + { + int counterLcHadron = 0; + registry.fill(HIST("hMcEvtCount"), 0); + BinningTypeMcGen corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true}; + poolBin = corrBinningMcGen.getBin(std::make_tuple(mcCollision.posZ(), mcCollision.multMCFT0A())); + registry.fill(HIST("hMultFT0AMcGen"), mcCollision.multMCFT0A()); -// find leading particle -if (correlateLcWithLeadingParticle) { -leadingIndex = findLeadingParticleMcGen(mcParticles, etaTrackMax.value, ptTrackMin.value); -} + // find leading particle + if (correlateLcWithLeadingParticle) { + leadingIndex = findLeadingParticleMcGen(mcParticles, etaTrackMax.value, ptTrackMin.value); + } -// Mc Gen level -for (const auto& particle : mcParticles) { -if (std::abs(particle.pdgCode()) != Pdg::kLambdaCPlus) { -continue; -} -if (!TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_3prong::DecayType::LcToPKPi)) { -continue; -} -double yL = RecoDecay::y(particle.pVector(), MassLambdaCPlus); -if (std::abs(yL) > yCandGenMax || particle.pt() < ptCandMin) { -continue; -} -registry.fill(HIST("hCandBin"), poolBin); -registry.fill(HIST("hPtCandMcGen"), particle.pt()); -registry.fill(HIST("hEtaMcGen"), particle.eta()); -registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); -registry.fill(HIST("hYMcGen"), yL); - -isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; -isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; -if (isPrompt) { -registry.fill(HIST("hPtCandMcGenPrompt"), particle.pt()); -} else if (isNonPrompt) { -registry.fill(HIST("hPtCandMcGenNonPrompt"), particle.pt()); -} + // Mc Gen level + for (const auto& particle : mcParticles) { + if (std::abs(particle.pdgCode()) != Pdg::kLambdaCPlus) { + continue; + } + if (!TESTBIT(std::abs(particle.flagMcMatchGen()), aod::hf_cand_3prong::DecayType::LcToPKPi)) { + continue; + } + double yL = RecoDecay::y(particle.pVector(), MassLambdaCPlus); + if (std::abs(yL) > yCandGenMax || particle.pt() < ptCandMin) { + continue; + } + registry.fill(HIST("hCandBin"), poolBin); + registry.fill(HIST("hPtCandMcGen"), particle.pt()); + registry.fill(HIST("hEtaMcGen"), particle.eta()); + registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); + registry.fill(HIST("hYMcGen"), yL); + + isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; + isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; + if (isPrompt) { + registry.fill(HIST("hPtCandMcGenPrompt"), particle.pt()); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandMcGenNonPrompt"), particle.pt()); + } -// prompt and non-prompt division -std::vector listDaughters{}; -std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; -std::array prongsId; -listDaughters.clear(); -RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); -int counterDaughters = 0; -if (listDaughters.size() == nDaughters) { -for (const auto& dauIdx : listDaughters) { -auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); -counterDaughters += 1; -prongsId[counterDaughters - 1] = daughI.globalIndex(); -} -} -counterLcHadron++; -// Lc Hadron correlation dedicated section -// if it's a Lc particle, search for Hadron and evalutate correlations -registry.fill(HIST("hcountCandtriggersMcGen"), 0, particle.pt()); // to count trigger Lc for normalisation -for (const auto& particleAssoc : mcParticles) { -if (std::abs(particleAssoc.eta()) > etaTrackMax || particleAssoc.pt() < ptTrackMin || particleAssoc.pt() > ptTrackMax) { -continue; -} -if (particleAssoc.globalIndex() == prongsId[0] || particleAssoc.globalIndex() == prongsId[1] || particleAssoc.globalIndex() == prongsId[2]) { -if (!storeAutoCorrelationFlag) { -continue; -} -correlationStatus = true; -} + // prompt and non-prompt division + std::vector listDaughters{}; + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + std::array prongsId; + listDaughters.clear(); + RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); + int counterDaughters = 0; + if (listDaughters.size() == nDaughters) { + for (const auto& dauIdx : listDaughters) { + auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); + counterDaughters += 1; + prongsId[counterDaughters - 1] = daughI.globalIndex(); + } + } + counterLcHadron++; + // Lc Hadron correlation dedicated section + // if it's a Lc particle, search for Hadron and evalutate correlations + registry.fill(HIST("hcountCandtriggersMcGen"), 0, particle.pt()); // to count trigger Lc for normalisation + for (const auto& particleAssoc : mcParticles) { + if (std::abs(particleAssoc.eta()) > etaTrackMax || particleAssoc.pt() < ptTrackMin || particleAssoc.pt() > ptTrackMax) { + continue; + } + if (particleAssoc.globalIndex() == prongsId[0] || particleAssoc.globalIndex() == prongsId[1] || particleAssoc.globalIndex() == prongsId[2]) { + if (!storeAutoCorrelationFlag) { + continue; + } + correlationStatus = true; + } -if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { -continue; -} + if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { + continue; + } -if (pidTrkApplied && (std::abs(particleAssoc.pdgCode()) != kProton)) -continue; // proton PID + if (pidTrkApplied && (std::abs(particleAssoc.pdgCode()) != kProton)) + continue; // proton PID -if (!particleAssoc.isPhysicalPrimary()) { -continue; -} + if (!particleAssoc.isPhysicalPrimary()) { + continue; + } -if (correlateLcWithLeadingParticle) { -if (particleAssoc.globalIndex() != leadingIndex) { -continue; -} -} + if (correlateLcWithLeadingParticle) { + if (particleAssoc.globalIndex() != leadingIndex) { + continue; + } + } -int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge -int8_t chargeAssoc = pdg->GetParticle(particleAssoc.pdgCode())->Charge(); // Retrieve charge - -int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, particleAssoc, true); -registry.fill(HIST("hPtParticleAssocMcGen"), particleAssoc.pt()); -entryCandHadronPair(getDeltaPhi(particleAssoc.phi(), particle.phi()), - particleAssoc.eta() - particle.eta(), - particle.pt() * chargeLc / std::abs(chargeLc), - particleAssoc.pt() * chargeAssoc / std::abs(chargeAssoc), - poolBin, - correlationStatus); -entryCandHadronPairY(particleAssoc.y() - yL); -entryCandHadronRecoInfo(MassLambdaCPlus, true); -entryCandHadronGenInfo(isPrompt, particleAssoc.isPhysicalPrimary(), trackOrigin); -} // end inner loop -} // end outer loop -registry.fill(HIST("hcountCandHadronPerEvent"), counterLcHadron); -registry.fill(HIST("hZvtx"), mcCollision.posZ()); -} -PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGen, "Process Mc Gen mode", false); + int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge + int8_t chargeAssoc = pdg->GetParticle(particleAssoc.pdgCode())->Charge(); // Retrieve charge + int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, particleAssoc, true); + registry.fill(HIST("hPtParticleAssocMcGen"), particleAssoc.pt()); + entryCandHadronPair(getDeltaPhi(particleAssoc.phi(), particle.phi()), + particleAssoc.eta() - particle.eta(), + particle.pt() * chargeLc / std::abs(chargeLc), + particleAssoc.pt() * chargeAssoc / std::abs(chargeAssoc), + poolBin, + correlationStatus); + entryCandHadronPairY(particleAssoc.y() - yL); + entryCandHadronRecoInfo(MassLambdaCPlus, true); + entryCandHadronGenInfo(isPrompt, particleAssoc.isPhysicalPrimary(), trackOrigin); + } // end inner loop + } // end outer loop + registry.fill(HIST("hcountCandHadronPerEvent"), counterLcHadron); + registry.fill(HIST("hZvtx"), mcCollision.posZ()); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGen, "Process Mc Gen mode", false); void processMcGenMixedEvent(SelCollisionsWithLcMc const& collisions, CandidatesLcMcGen const& mcParticles) @@ -1061,11 +1057,11 @@ PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGen, "Process Mc Gen mode", fal int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, particleAssoc, true); bool isPrompt = candidate.originMcGen() == RecoDecay::OriginType::Prompt; entryCandHadronPair(getDeltaPhi(particleAssoc.phi(), candidate.phi()), - particleAssoc.eta() - candidate.eta(), - candidate.pt() * chargeLc / std::abs(chargeLc), - particleAssoc.pt() * chargeAssoc / std::abs(chargeAssoc), - poolBin, - correlationStatus); + particleAssoc.eta() - candidate.eta(), + candidate.pt() * chargeLc / std::abs(chargeLc), + particleAssoc.pt() * chargeAssoc / std::abs(chargeAssoc), + poolBin, + correlationStatus); entryCandHadronPairY(particleAssoc.y() - yL); entryCandHadronRecoInfo(MassLambdaCPlus, true); entryCandHadronGenInfo(isPrompt, particleAssoc.isPhysicalPrimary(), trackOrigin); From 61007d1123e277331abd178c04efa0095b9be58e Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 27 May 2025 23:52:46 +0200 Subject: [PATCH 04/35] Update CorrelationTables.h --- PWGHF/HFC/DataModel/CorrelationTables.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/PWGHF/HFC/DataModel/CorrelationTables.h b/PWGHF/HFC/DataModel/CorrelationTables.h index 370f3738975..7eaed7ce203 100644 --- a/PWGHF/HFC/DataModel/CorrelationTables.h +++ b/PWGHF/HFC/DataModel/CorrelationTables.h @@ -145,6 +145,7 @@ DECLARE_SOA_COLUMN(DeltaY, deltaY, float); //! D DECLARE_SOA_COLUMN(PtLc, ptLc, float); //! Transverse momentum of Lc DECLARE_SOA_COLUMN(PtHadron, ptHadron, float); //! Transverse momentum of Hadron DECLARE_SOA_COLUMN(MLc, mLc, float); //! Invariant mass of Lc +DECLARE_SOA_COLUMN(ChargeCand, chargeCand, int); //! store charge of Lc and Sc DECLARE_SOA_COLUMN(MlScoreBkg, mlScoreBkg, float); //! ML background score for Lc selection DECLARE_SOA_COLUMN(MlScorePrompt, mlScorePrompt, float); //! ML prompt score for Lc selection DECLARE_SOA_COLUMN(SignalStatus, signalStatus, int); //! Tag for LcToPKPi/LcToPiKP @@ -213,8 +214,12 @@ DECLARE_SOA_TABLE(TrkRecInfoLc, "AOD", "TRKRECINFOLC", //! Tracks Reconstructed aod::hf_correlation_lc_hadron::TrackDcaXY, aod::hf_correlation_lc_hadron::TrackDcaZ, aod::hf_correlation_lc_hadron::TrackTPCNClsCrossedRows); -DECLARE_SOA_TABLE(LcHadronPairY, "AOD", "LCHPAIRY", //! Lc candidates Generated Information +DECLARE_SOA_TABLE(LcHadronPairY, "AOD", "LCHPAIRY", aod::hf_correlation_lc_hadron::DeltaY); +DECLARE_SOA_TABLE(CandChargePair, "AOD", "CANDCHARGEPAIR", + aod::hf_correlation_lc_hadron::ChargeCand); +DECLARE_SOA_TABLE(CandCharge, "AOD", "CANDCHARGE", + aod::hf_correlation_lc_hadron::ChargeCand); // definition of columns and tables for Ds-Hadron correlation pairs namespace hf_correlation_ds_hadron { From 90f9f45400e8ce2cafeee931eef8a1f4d2f7314c Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 28 May 2025 00:35:54 +0200 Subject: [PATCH 05/35] Update correlatorLcScHadrons.cxx --- .../HFC/TableProducer/correlatorLcScHadrons.cxx | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 8a50f6517b9..595e6cacc47 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -9,7 +9,7 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. -/// \file correlatorLcHadrons.cxx +/// \file correlatorLcScHadrons.cxx /// \brief Lc-Hadrons correlator task - data-like, Mc-Reco and Mc-Gen analyses /// /// \author Marianna Mazzilli @@ -348,10 +348,11 @@ struct HfCorrelatorLcScHadrons { double estimateY(candtype& cand) { double y = -999.; + const int chargeScZero = 0; if constexpr (isCandSc) { int8_t chargeCand = cand.charge(); - if (chargeCand == 0) { + if (chargeCand == chargeScZero) { y = hfHelper.ySc0(cand); } else { y = hfHelper.yScPlusPlus(cand); @@ -459,6 +460,8 @@ struct HfCorrelatorLcScHadrons { int nTracks = 0; int64_t timeStamp = 0; + const int chargeScPlusPlus = 2; + const int chargeScZero = 0; bool skipMixedEventTableFilling = false; float multiplicityFT0M = collision.multFT0M(); int gCollisionId = collision.globalIndex(); @@ -558,8 +561,8 @@ struct HfCorrelatorLcScHadrons { // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || // (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); isSignal = - (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || - (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == chargeScZero) || + (std::abs(candidate.flagMcMatchRec()) == (1 << aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == chargeScPlusPlus); auto trackPos1 = candidateLc.template prong0_as(); auto trackPos2 = candidateLc.template prong2_as(); @@ -735,6 +738,8 @@ struct HfCorrelatorLcScHadrons { double massCandPiKP = -999.0; bool selLcPKPi = false; bool selLcPiKP = false; + const int chargeScPlusPlus = 2; + const int chargeScZero = 0; auto tracksTuple = std::make_tuple(candidates, tracks); Pair pairData{corrBinning, numberEventsMixed, -1, collisions, tracksTuple, &cache}; @@ -772,8 +777,8 @@ struct HfCorrelatorLcScHadrons { } if constexpr (isMcRec) { isSignal = - (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == 0) || - (TESTBIT(abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == 2); + (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi) && chargeCand == chargeScZero) || + (TESTBIT(std::abs(candidate.flagMcMatchRec()), aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi) && std::abs(chargeCand) == chargeScPlusPlus); } } else { selLcPKPi = candidate.isSelLcToPKPi() >= selectionFlagLc; From d11b16b6865ae1db5a6dd1b17105df12167cdd36 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 28 May 2025 01:01:51 +0200 Subject: [PATCH 06/35] Update correlatorLcScHadrons.cxx --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 595e6cacc47..aa78b023049 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -713,7 +713,7 @@ struct HfCorrelatorLcScHadrons { registry.fill(HIST("hTracksBin"), poolBin); } } - } // Hadron Tracks loop + } // end Hadron Tracks loop countCand++; } // end outer Lc loop registry.fill(HIST("hZvtx"), collision.posZ()); From a5fd339611cc8237772090fb9243f7f4ab0d281f Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Sat, 31 May 2025 00:25:44 +0200 Subject: [PATCH 07/35] Update correlatorLcScHadrons.cxx --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index aa78b023049..b79fc2cdeca 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -30,6 +30,7 @@ #include "Common/DataModel/EventSelection.h" #include "Common/DataModel/Multiplicity.h" #include "Common/DataModel/TrackSelectionTables.h" +#include "CommonConstants/MathConstants.h" #include "PWGHF/Core/HfHelper.h" #include "PWGHF/DataModel/CandidateReconstructionTables.h" From c43b13030213e41f5ea2473bf56c246e97f8b03b Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Mon, 2 Jun 2025 01:02:49 +0200 Subject: [PATCH 08/35] Update correlatorLcScHadrons.cxx --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index b79fc2cdeca..e1c4e425976 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -33,6 +33,7 @@ #include "CommonConstants/MathConstants.h" #include "PWGHF/Core/HfHelper.h" +#include "PWGHF/Core/SelectorCuts.h" #include "PWGHF/DataModel/CandidateReconstructionTables.h" #include "PWGHF/DataModel/CandidateSelectionTables.h" #include "PWGHF/HFC/DataModel/CorrelationTables.h" From 92581ad72793f1a657b2b126bcdd9f2a6e078e91 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Mon, 2 Jun 2025 01:04:43 +0200 Subject: [PATCH 09/35] Update CorrelationTables.h --- PWGHF/HFC/DataModel/CorrelationTables.h | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/PWGHF/HFC/DataModel/CorrelationTables.h b/PWGHF/HFC/DataModel/CorrelationTables.h index 7eaed7ce203..39dd8d4b112 100644 --- a/PWGHF/HFC/DataModel/CorrelationTables.h +++ b/PWGHF/HFC/DataModel/CorrelationTables.h @@ -16,12 +16,15 @@ #ifndef PWGHF_HFC_DATAMODEL_CORRELATIONTABLES_H_ #define PWGHF_HFC_DATAMODEL_CORRELATIONTABLES_H_ -#include "CommonConstants/PhysicsConstants.h" -#include "Framework/AnalysisDataModel.h" +#include +#include // NOLINT +#include + +#include #include "Common/Core/RecoDecay.h" -#include "PWGHF/DataModel/CandidateReconstructionTables.h" +#include "PWGHF/DataModel/CandidateReconstructionTables.h" // NOLINT namespace o2::aod { @@ -144,8 +147,8 @@ DECLARE_SOA_COLUMN(DeltaEta, deltaEta, float); //! D DECLARE_SOA_COLUMN(DeltaY, deltaY, float); //! DeltaY between Lc and Hadrons DECLARE_SOA_COLUMN(PtLc, ptLc, float); //! Transverse momentum of Lc DECLARE_SOA_COLUMN(PtHadron, ptHadron, float); //! Transverse momentum of Hadron -DECLARE_SOA_COLUMN(MLc, mLc, float); //! Invariant mass of Lc DECLARE_SOA_COLUMN(ChargeCand, chargeCand, int); //! store charge of Lc and Sc +DECLARE_SOA_COLUMN(MLc, mLc, float); //! Invariant mass of Lc DECLARE_SOA_COLUMN(MlScoreBkg, mlScoreBkg, float); //! ML background score for Lc selection DECLARE_SOA_COLUMN(MlScorePrompt, mlScorePrompt, float); //! ML prompt score for Lc selection DECLARE_SOA_COLUMN(SignalStatus, signalStatus, int); //! Tag for LcToPKPi/LcToPiKP @@ -214,12 +217,14 @@ DECLARE_SOA_TABLE(TrkRecInfoLc, "AOD", "TRKRECINFOLC", //! Tracks Reconstructed aod::hf_correlation_lc_hadron::TrackDcaXY, aod::hf_correlation_lc_hadron::TrackDcaZ, aod::hf_correlation_lc_hadron::TrackTPCNClsCrossedRows); + DECLARE_SOA_TABLE(LcHadronPairY, "AOD", "LCHPAIRY", aod::hf_correlation_lc_hadron::DeltaY); DECLARE_SOA_TABLE(CandChargePair, "AOD", "CANDCHARGEPAIR", aod::hf_correlation_lc_hadron::ChargeCand); DECLARE_SOA_TABLE(CandCharge, "AOD", "CANDCHARGE", aod::hf_correlation_lc_hadron::ChargeCand); + // definition of columns and tables for Ds-Hadron correlation pairs namespace hf_correlation_ds_hadron { From 2e27032bc0f857a6f6e007c516ef1cf41e8f04a1 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Sun, 1 Jun 2025 23:05:12 +0000 Subject: [PATCH 10/35] Please consider the following formatting changes --- PWGHF/HFC/DataModel/CorrelationTables.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/HFC/DataModel/CorrelationTables.h b/PWGHF/HFC/DataModel/CorrelationTables.h index 39dd8d4b112..eaf0b4f3c4a 100644 --- a/PWGHF/HFC/DataModel/CorrelationTables.h +++ b/PWGHF/HFC/DataModel/CorrelationTables.h @@ -217,7 +217,7 @@ DECLARE_SOA_TABLE(TrkRecInfoLc, "AOD", "TRKRECINFOLC", //! Tracks Reconstructed aod::hf_correlation_lc_hadron::TrackDcaXY, aod::hf_correlation_lc_hadron::TrackDcaZ, aod::hf_correlation_lc_hadron::TrackTPCNClsCrossedRows); - + DECLARE_SOA_TABLE(LcHadronPairY, "AOD", "LCHPAIRY", aod::hf_correlation_lc_hadron::DeltaY); DECLARE_SOA_TABLE(CandChargePair, "AOD", "CANDCHARGEPAIR", From 8c1000f065198340e9fa3423f51a5666e0859e28 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 3 Jun 2025 10:35:21 +0200 Subject: [PATCH 11/35] Update correlatorLcScHadrons.cxx --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index e1c4e425976..0bfff38e0d6 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -220,7 +220,7 @@ struct HfCorrelatorLcScHadrons { bool isNonPrompt = false; bool isSignal = false; - static constexpr size_t nDaughters{3u}; + static constexpr size_t Ndaughters{3u}; TRandom3* rnd = new TRandom3(0); std::vector outputMl = {-1., -1., -1.}; std::vector outputMlPKPi = {-1., -1., -1.}; @@ -965,12 +965,12 @@ struct HfCorrelatorLcScHadrons { // prompt and non-prompt division std::vector listDaughters{}; - std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; - std::array prongsId; + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + std::array prongsId; listDaughters.clear(); RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); int counterDaughters = 0; - if (listDaughters.size() == nDaughters) { + if (listDaughters.size() == Ndaughters) { for (const auto& dauIdx : listDaughters) { auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); counterDaughters += 1; From f3015dfadea4fa29b052f3c11d2541cd9eee109a Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 3 Jun 2025 12:00:32 +0200 Subject: [PATCH 12/35] Update correlatorLcScHadrons.cxx --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 0bfff38e0d6..a25b0cea1fa 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -220,7 +220,7 @@ struct HfCorrelatorLcScHadrons { bool isNonPrompt = false; bool isSignal = false; - static constexpr size_t Ndaughters{3u}; + static constexpr size_t NDaughters{3u}; TRandom3* rnd = new TRandom3(0); std::vector outputMl = {-1., -1., -1.}; std::vector outputMlPKPi = {-1., -1., -1.}; @@ -965,12 +965,12 @@ struct HfCorrelatorLcScHadrons { // prompt and non-prompt division std::vector listDaughters{}; - std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; - std::array prongsId; + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + std::array prongsId; listDaughters.clear(); RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); int counterDaughters = 0; - if (listDaughters.size() == Ndaughters) { + if (listDaughters.size() == NDaughters) { for (const auto& dauIdx : listDaughters) { auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); counterDaughters += 1; From 75aa865c43f4a000e5c4df9e3ebaa89987ce8536 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 3 Jun 2025 16:02:16 +0200 Subject: [PATCH 13/35] Update correlatorLcScHadrons.cxx --- .../TableProducer/correlatorLcScHadrons.cxx | 82 ++++++++----------- 1 file changed, 36 insertions(+), 46 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index a25b0cea1fa..6685b77425c 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -338,51 +338,36 @@ struct HfCorrelatorLcScHadrons { corrBinning = {{binsZVtx, binsMultiplicity}, true}; } - template - void fillMlOutput(mlProbType& mlProb, std::vector& outputMl) + template + void fillMlOutput(MlProbType const& mlProb, std::vector& outputMl) { for (unsigned int iclass = 0; iclass < classMl->size(); iclass++) { outputMl[iclass] = mlProb[classMl->at(iclass)]; } }; - template - double estimateY(candtype& cand) + template + double estimateY(CandType const& candidate) { double y = -999.; const int chargeScZero = 0; if constexpr (isCandSc) { - int8_t chargeCand = cand.charge(); + int8_t chargeCand = candidate.charge(); if (chargeCand == chargeScZero) { - y = hfHelper.ySc0(cand); + y = hfHelper.ySc0(candidate); } else { - y = hfHelper.yScPlusPlus(cand); + y = hfHelper.yScPlusPlus(candidate); } } else { - y = hfHelper.yLc(cand); + y = hfHelper.yLc(candidate); } return y; } - template - int isDecayToPKPiToPiKP(L& candidateLc, S& candSc) - { - int channel = 0; - if ((candidateLc.isSelLcToPKPi() >= 1) && candSc.statusSpreadLcMinvPKPiFromPDG()) { - // Λc+ → pK-π+ and within the requested mass to build the Σc0,++ - channel += 1; - } - if ((candidateLc.isSelLcToPiKP() >= 1) && candSc.statusSpreadLcMinvPiKPFromPDG()) { - // Λc+ → π+K-p and within the requested mass to build the Σc0,++ - channel += 2; - } - return channel; /// 0: none; 1: pK-π+ only; 2: π+K-p only; 3: both possible - } - - template - void calculateTrkEff(t1& trackPos1, t2& trackPos2, mcPart& mcParticles) + template + void calculateTrkEff(T1 const& trackPos1, T2 const& trackPos2, McPart const& mcParticles) { // genrated tracks decltype(trackPos1.template mcParticle_as()) mctrk{}; @@ -417,43 +402,43 @@ struct HfCorrelatorLcScHadrons { registry.fill(HIST("hPtTracksVsSignGen"), track.pt(), chargeTrack / (2 * std::abs(chargeTrack))); } } - template - void fillCorrelationTable(bool trkPidFill, tracktype& trk, candtype& cand, std::vector outMl, int binPool, int8_t correlStatus, double candY, int signCand, mcPart& mcParticles) + template + void fillCorrelationTable(bool trkPidFill, TrackType const& track, CandType const& candidate, std::vector const outMl, int binPool, int8_t correlStatus, double yCand, int signCand, McPart const& mcParticles) { bool isPhysicalPrimary = false; int trackOrigin = -1; - entryCandHadronPair(getDeltaPhi(trk.phi(), cand.phi()), - trk.eta() - cand.eta(), - cand.pt(), - trk.pt() * trk.sign(), + entryCandHadronPair(getDeltaPhi(track.phi(), candidate.phi()), + track.eta() - candidate.eta(), + candidate.pt(), + track.pt() * track.sign(), binPool, correlStatus); - entryCandHadronPairY(trk.y() - candY); + entryCandHadronPairY(track.y() - yCand); entryCandHadronMlInfo(outMl[0], outMl[1]); - entryTrackRecoInfo(trk.dcaXY(), trk.dcaZ(), trk.tpcNClsCrossedRows()); + entryTrackRecoInfo(track.dcaXY(), track.dcaZ(), track.tpcNClsCrossedRows()); entryPairCandCharge(signCand); if (trkPidFill) { - entryCandHadronPairTrkPID(trk.tpcNSigmaPr(), trk.tpcNSigmaKa(), trk.tpcNSigmaPi(), trk.tofNSigmaPr(), trk.tofNSigmaKa(), trk.tofNSigmaPi()); + entryCandHadronPairTrkPID(track.tpcNSigmaPr(), track.tpcNSigmaKa(), track.tpcNSigmaPi(), track.tofNSigmaPr(), track.tofNSigmaKa(), track.tofNSigmaPi()); } if constexpr (isMcRec) { - if (trk.has_mcParticle()) { - auto mcParticle = trk.template mcParticle_as(); + if (track.has_mcParticle()) { + auto mcParticle = track.template mcParticle_as(); isPhysicalPrimary = mcParticle.isPhysicalPrimary(); trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, mcParticle, true); entryCandHadronGenInfo(isPrompt, isPhysicalPrimary, trackOrigin); } else { entryCandHadronGenInfo(isPrompt, false, 0); - registry.fill(HIST("hFakeTracksMcRec"), trk.pt()); + registry.fill(HIST("hFakeTracksMcRec"), track.pt()); } - registry.fill(HIST("hPtParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); + registry.fill(HIST("hPtParticleAssocVsCandMcRec"), track.pt(), candidate.pt()); if (isPhysicalPrimary) { - registry.fill(HIST("hPtPrimaryParticleAssocVsCandMcRec"), trk.pt(), cand.pt()); + registry.fill(HIST("hPtPrimaryParticleAssocVsCandMcRec"), track.pt(), candidate.pt()); } } } - template + template void doSameEvent(CollisionType const& collision, TrackType const& tracks, CandType const& candidates, @@ -722,7 +707,7 @@ struct HfCorrelatorLcScHadrons { registry.fill(HIST("hMultFT0M"), multiplicityFT0M); } - template + template void doMixEvent(CollisionType const& collisions, TrackType const& tracks, CandType const& candidates, @@ -845,7 +830,8 @@ struct HfCorrelatorLcScHadrons { /// Lc-hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via MC truth) void processDataLc(SelCollisionsWithLc::iterator const& collision, TracksData const& tracks, - CandsLcDataFiltered const& candidates, aod::BCsWithTimestamps const&) + CandsLcDataFiltered const& candidates, + aod::BCsWithTimestamps const&) { doSameEvent(collision, tracks, candidates); } @@ -854,7 +840,8 @@ struct HfCorrelatorLcScHadrons { void processDataSc(SelCollisionsWithSc::iterator const& collision, TracksData const& tracks, aod::Tracks const&, - aod::HfCandSc const& candidates, CandsLcData const&, + aod::HfCandSc const& candidates, + CandsLcData const&, aod::BCsWithTimestamps const&) // MUST be last among index-compatible { doSameEvent(collision, tracks, candidates); @@ -875,7 +862,8 @@ struct HfCorrelatorLcScHadrons { void processMcRecSc(SelCollisionsWithSc::iterator const& collision, TracksWithMc const& tracks, aod::TracksWMc const&, - soa::Join const& candidates, + soa::Join const& candidates, CandsLcData const&, aod::McParticles const& mcParticles) { @@ -886,7 +874,8 @@ struct HfCorrelatorLcScHadrons { void processDataMixedEventSc(SelCollisionsWithSc const& collisions, TracksData const& tracks, aod::Tracks const&, - aod::HfCandSc const& candidates, CandsLcData const&) + aod::HfCandSc const& candidates, + CandsLcData const&) { doMixEvent(collisions, tracks, candidates); } @@ -904,7 +893,8 @@ struct HfCorrelatorLcScHadrons { void processMcRecMixedEventSc(SelCollisionsWithSc const& collisions, TracksWithMc const& tracks, aod::TracksWMc const&, - soa::Join const& candidates, + soa::Join const& candidates, CandsLcData const&, aod::McParticles const& mcParticles) { From 03c0e7314c7ab2269cfa71c667c78476d9f97bf2 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 3 Jun 2025 14:02:52 +0000 Subject: [PATCH 14/35] Please consider the following formatting changes --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 6685b77425c..910867ad873 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -831,7 +831,7 @@ struct HfCorrelatorLcScHadrons { void processDataLc(SelCollisionsWithLc::iterator const& collision, TracksData const& tracks, CandsLcDataFiltered const& candidates, - aod::BCsWithTimestamps const&) + aod::BCsWithTimestamps const&) { doSameEvent(collision, tracks, candidates); } @@ -841,7 +841,7 @@ struct HfCorrelatorLcScHadrons { TracksData const& tracks, aod::Tracks const&, aod::HfCandSc const& candidates, - CandsLcData const&, + CandsLcData const&, aod::BCsWithTimestamps const&) // MUST be last among index-compatible { doSameEvent(collision, tracks, candidates); @@ -863,7 +863,7 @@ struct HfCorrelatorLcScHadrons { TracksWithMc const& tracks, aod::TracksWMc const&, soa::Join const& candidates, + aod::HfCandScMcRec> const& candidates, CandsLcData const&, aod::McParticles const& mcParticles) { @@ -875,7 +875,7 @@ struct HfCorrelatorLcScHadrons { TracksData const& tracks, aod::Tracks const&, aod::HfCandSc const& candidates, - CandsLcData const&) + CandsLcData const&) { doMixEvent(collisions, tracks, candidates); } @@ -894,7 +894,7 @@ struct HfCorrelatorLcScHadrons { TracksWithMc const& tracks, aod::TracksWMc const&, soa::Join const& candidates, + aod::HfCandScMcRec> const& candidates, CandsLcData const&, aod::McParticles const& mcParticles) { From 64737f6edace2317c74002daafba8d51b1954c24 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 4 Jun 2025 18:32:02 +0200 Subject: [PATCH 15/35] Update correlatorLcScHadrons.cxx --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 910867ad873..bad99794546 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -346,7 +346,7 @@ struct HfCorrelatorLcScHadrons { } }; - template + template double estimateY(CandType const& candidate) { double y = -999.; @@ -403,7 +403,9 @@ struct HfCorrelatorLcScHadrons { } } template - void fillCorrelationTable(bool trkPidFill, TrackType const& track, CandType const& candidate, std::vector const outMl, int binPool, int8_t correlStatus, double yCand, int signCand, McPart const& mcParticles) + void fillCorrelationTable(bool trkPidFill, TrackType const& track, CandType const& candidate, + const std::vector& outMl, int binPool, int8_t correlStatus, + double yCand, int signCand, McPart const& mcParticles) { bool isPhysicalPrimary = false; int trackOrigin = -1; From 6b0268ffcf23d7553fdb9ac8867e1f56c59369d2 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 4 Jun 2025 16:32:28 +0000 Subject: [PATCH 16/35] Please consider the following formatting changes --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index bad99794546..56197e33c22 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -404,8 +404,8 @@ struct HfCorrelatorLcScHadrons { } template void fillCorrelationTable(bool trkPidFill, TrackType const& track, CandType const& candidate, - const std::vector& outMl, int binPool, int8_t correlStatus, - double yCand, int signCand, McPart const& mcParticles) + const std::vector& outMl, int binPool, int8_t correlStatus, + double yCand, int signCand, McPart const& mcParticles) { bool isPhysicalPrimary = false; int trackOrigin = -1; From c96cdcde715f37bffbcd03a3f67d6fe6bf287dda Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 4 Jun 2025 20:43:01 +0200 Subject: [PATCH 17/35] Changed C-style casting to modern c++ style casting --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 56197e33c22..77c31d17969 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -270,8 +270,8 @@ struct HfCorrelatorLcScHadrons { AxisSpec axisCandMass = {binsCandMass, "inv. mass (p K #pi) (GeV/#it{c}^{2})"}; AxisSpec axisEta = {binsEta, "#it{eta}"}; AxisSpec axisPhi = {binsPhi, "#it{#varphi}"}; - AxisSpec axisPtLc = {(std::vector)binsPtLc, "#it{p}_{T} (GeV/#it{c})"}; - AxisSpec axisPtHadron = {(std::vector)binsPtHadron, "#it{p}_{T} Hadron (GeV/#it{c})"}; + AxisSpec axisPtLc = {static_cast>(binsPtLc), "#it{p}_{T} (GeV/#it{c})"}; + AxisSpec axisPtHadron = {static_cast>(binsPtHadron), "#it{p}_{T} Hadron (GeV/#it{c})"}; AxisSpec axisPtTrack = {500, 0, 50, "#it{p}_{T} Hadron (GeV/#it{c})"}; AxisSpec axisMultiplicity = {binsMultiplicity, "Multiplicity"}; AxisSpec axisMultFT0M = {binsMultFT0M, "MultiplicityFT0M"}; From 952df9584989b03dd01af43070cadc622384b97f Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 18 Jun 2025 20:35:42 +0200 Subject: [PATCH 18/35] PWGHF: added processes to filter Sc collisions --- .../TableProducer/correlatorLcScHadrons.cxx | 429 ++++++++++-------- 1 file changed, 235 insertions(+), 194 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 77c31d17969..d90a673eca0 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -60,7 +60,7 @@ using BinningTypeMcGen = ColumnBinningPolicy lcSel; + Produces candSel; Configurable useSel8{"useSel8", true, "Flag for applying sel8 for collision selection"}; Configurable selNoSameBunchPileUpColl{"selNoSameBunchPileUpColl", true, "Flag for rejecting the collisions associated with the same bunch crossing"}; @@ -75,54 +75,29 @@ struct HfCorrelatorLcScHadronsSelection { using SelCollisions = soa::Join; using CandsLcDataFiltered = soa::Filtered>; using CandsLcMcRecFiltered = soa::Filtered>; + using CandsScMcRec = soa::Join; using CandidatesLcMcGen = soa::Join; - + using CandidatesScMcGen = soa::Join; // filter on selection of Lc and decay channel Lc->PKPi Filter lcFilter = ((o2::aod::hf_track_index::hfflag & static_cast(1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) != static_cast(0)) && (aod::hf_sel_candidate_lc::isSelLcToPKPi >= selectionFlagLc || aod::hf_sel_candidate_lc::isSelLcToPiKP >= selectionFlagLc); - /// Code to select collisions with at least one Lc - for real data and data-like analysis - void processLcSelectionData(SelCollisions::iterator const& collision, - CandsLcDataFiltered const& candidates) + template + void selectionCollision(CollType const& collision, CandType const& candidates) { bool isSelColl = true; - bool isLcFound = true; + bool isCandFound = false; bool isSel8 = true; bool isNosameBunchPileUp = true; if (doSelLcCollision) { for (const auto& candidate : candidates) { - if (std::abs(hfHelper.yLc(candidate)) > yCandMax || candidate.pt() < ptCandMin) { - isLcFound = false; - continue; - } - isLcFound = true; - break; - } - } - if (useSel8) { - isSel8 = collision.sel8(); - } - if (selNoSameBunchPileUpColl) { - isNosameBunchPileUp = static_cast(collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)); - } - isSelColl = isLcFound && isSel8 && isNosameBunchPileUp; - lcSel(isSelColl); - } - PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionData, "Process Lc Collision Selection Data", true); - void processLcSelectionMcRec(SelCollisions::iterator const& collision, - CandsLcMcRecFiltered const& candidates) - { - bool isSelColl = true; - bool isLcFound = true; - bool isSel8 = true; - bool isNosameBunchPileUp = true; - if (doSelLcCollision) { - for (const auto& candidate : candidates) { - if (std::abs(hfHelper.yLc(candidate)) > yCandMax || candidate.pt() < ptCandMin) { - isLcFound = false; + auto yCand = estimateY(candidate); + + if (std::abs(yCand) > yCandMax || candidate.pt() < ptCandMin) { + isCandFound = false; continue; } - isLcFound = true; + isCandFound = true; break; } } @@ -132,31 +107,76 @@ struct HfCorrelatorLcScHadronsSelection { if (selNoSameBunchPileUpColl) { isNosameBunchPileUp = static_cast(collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)); } - isSelColl = isLcFound && isSel8 && isNosameBunchPileUp; - lcSel(isSelColl); + isSelColl = isCandFound && isSel8 && isNosameBunchPileUp; + candSel(isSelColl); } - PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); - void processLcSelectionMcGen(aod::McCollision const&, - CandidatesLcMcGen const& mcParticles) + template + void selectionCollisionMcGen(CandType const& mcParticles) { - bool isLcFound = true; + bool isCandFound = false; + double massCand = -999.0; for (const auto& particle : mcParticles) { - if (std::abs(particle.pdgCode()) != Pdg::kLambdaCPlus) { - isLcFound = false; + + isCandFound = matchCandAndMass(particle, massCand); + if (!isCandFound){ continue; } - double yL = RecoDecay::y(particle.pVector(), MassLambdaCPlus); - if (std::abs(yL) > yCandMax || particle.pt() < ptCandMin) { - isLcFound = false; + + double yCand = RecoDecay::y(particle.pVector(), massCand); + if (std::abs(yCand) > yCandMax || particle.pt() < ptCandMin) { + isCandFound = false; continue; } - isLcFound = true; + + isCandFound = true; break; } - lcSel(isLcFound); + candSel(isCandFound); + } + + /// Code to select collisions with at least one Lc - for real data and data-like analysis + void processLcSelection(SelCollisions::iterator const& collision, + CandsLcDataFiltered const& candidates) + { + selectionCollision(collision,candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelection, "Process Lc Collision Selection for Data and Mc", true); + + void processScSelection(SelCollisions::iterator const& collision, + aod::HfCandSc const& candidates) + { + selectionCollision(collision,candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelection, "Process Sc Collision Selection for Data and Mc", false); + + void processLcSelectionMcRec(SelCollisions::iterator const& collision, + CandsLcMcRecFiltered const& candidates) + { + selectionCollision(collision,candidates); + } +PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); + + void processScSelectionMcRec(SelCollisions::iterator const& collision, + CandsScMcRec const& candidates) + { + selectionCollision(collision,candidates); + } + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelectionMcRec, "Process Sc Selection McRec", false); + + void processLcSelectionMcGen(aod::McCollision const&, + CandidatesLcMcGen const& mcParticles) + { + selectionCollisionMcGen(mcParticles); } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcGen, "Process Lc Selection McGen", false); + + void processScSelectionMcGen(aod::McCollision const&, + CandidatesScMcGen const& mcParticles) + { + selectionCollisionMcGen(mcParticles); + } + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelectionMcGen, "Process Lc Selection McGen", false); }; // Lc-Hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via Mc truth) @@ -220,16 +240,15 @@ struct HfCorrelatorLcScHadrons { bool isNonPrompt = false; bool isSignal = false; - static constexpr size_t NDaughters{3u}; TRandom3* rnd = new TRandom3(0); - std::vector outputMl = {-1., -1., -1.}; + //std::vector outputMl = {-1., -1., -1.}; std::vector outputMlPKPi = {-1., -1., -1.}; std::vector outputMlPiKP = {-1., -1., -1.}; // Event Mixing for the Data Mode - using SelCollisionsWithSc = soa::Join; - using SelCollisionsWithLc = soa::Filtered>; - using SelCollisionsWithLcMc = soa::Filtered>; // collisionFilter applied + //using SelCollisionsWithSc = soa::Join; + using SelCollisions = soa::Filtered>; + using SelCollisionsMc = soa::Filtered>; // collisionFilter applied using CandsLcData = soa::Join; using CandsLcDataFiltered = soa::Filtered; @@ -238,6 +257,8 @@ struct HfCorrelatorLcScHadrons { using CandsLcMcRec = soa::Join; using CandsLcMcRecFiltered = soa::Filtered; using CandidatesLcMcGen = soa::Join; // flagLcFilter applied + using CandsScMcRec = soa::Join; + using CandidatesScMcGen = soa::Join; // Event Mixing for the MCGen Mode using McCollisionsSel = soa::Filtered>; using McParticlesSel = soa::Filtered; @@ -279,7 +300,7 @@ struct HfCorrelatorLcScHadrons { AxisSpec axisBdtScore = {binsBdtScore, "Bdt score"}; AxisSpec axisPoolBin = {binsPoolBin, "PoolBin"}; AxisSpec axisRapidity = {100, -2, 2, "Rapidity"}; - AxisSpec axisSign = {2, -1, 1, "Sign"}; + AxisSpec axisSign = {5, -2.5, 2.5, "Sign"}; registry.add("hPtCand", "Lc,Hadron candidates;candidate #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); registry.add("hPtProng0", "Lc,Hadron candidates;prong 0 #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); @@ -297,6 +318,7 @@ struct HfCorrelatorLcScHadrons { registry.add("hCandBin", "Lc selected in pool Bin;pool Bin;entries", {HistType::kTH1F, {{9, 0., 9.}}}); registry.add("hTracksBin", "Tracks selected in pool Bin;pool Bin;entries", {HistType::kTH1F, {{9, 0., 9.}}}); registry.add("hMassLcVsPt", "Lc candidates;inv. mass (p K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH2F, {{axisCandMass}, {axisPtLc}}}); + registry.add("hMassScVsPtVsSign", "Sc candidates;inv. mass (p K #pi) (GeV/#it{c}^{2});sign;entries", {HistType::kTH3F, {{axisCandMass}, {axisPtLc}, {axisSign}}}); registry.add("hMassLcData", "Lc candidates;inv. mass (p K #pi) (GeV/#it{c}^{2});entries", {HistType::kTH1F, {{axisCandMass}}}); registry.add("hLcPoolBin", "Lc candidates pool bin", {HistType::kTH1F, {axisPoolBin}}); registry.add("hTracksPoolBin", "Particles associated pool bin", {HistType::kTH1F, {axisPoolBin}}); @@ -329,7 +351,9 @@ struct HfCorrelatorLcScHadrons { registry.add("hPtCandMcGen", "Lc,Hadron particles - MC gen;particle #it{p}_{T} (GeV/#it{c});entries", {HistType::kTH1F, {axisPtLc}}); registry.add("hYMcGen", "Lc,Hadron candidates - MC gen;candidate #it{#y};entries", {HistType::kTH1F, {axisRapidity}}); registry.add("hPtCandMcGenPrompt", "Lc,Hadron particles - MC Gen Prompt", {HistType::kTH1F, {axisPtLc}}); - registry.add("hPtCandMcGenNonPrompt", "Lc,Hadron particles - MC Gen Non Prompt", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtCandVsChargeMcGenPrompt", "Charm Hadron particles - MC Gen Prompt", {HistType::kTH2F, {{axisPtLc}, {axisSign}}}); + registry.add("hPtCandMcGenNonPrompt", "Charm Hadron particles - MC Gen Non Prompt", {HistType::kTH1F, {axisPtLc}}); + registry.add("hPtCandVsChargeMcGenNonPrompt", "Lc,Hadron particles - MC Gen Non Prompt", {HistType::kTH2F, {{axisPtLc}, {axisSign}}}); registry.add("hPtParticleAssocMcGen", "Associated Particle - MC Gen", {HistType::kTH1F, {axisPtHadron}}); registry.add("hEtaMcGen", "Lc,Hadron particles - MC Gen", {HistType::kTH1F, {axisEta}}); registry.add("hPhiMcGen", "Lc,Hadron particles - MC Gen", {HistType::kTH1F, {axisPhi}}); @@ -346,26 +370,6 @@ struct HfCorrelatorLcScHadrons { } }; - template - double estimateY(CandType const& candidate) - { - double y = -999.; - const int chargeScZero = 0; - if constexpr (isCandSc) { - int8_t chargeCand = candidate.charge(); - - if (chargeCand == chargeScZero) { - y = hfHelper.ySc0(candidate); - } else { - y = hfHelper.yScPlusPlus(candidate); - } - - } else { - y = hfHelper.yLc(candidate); - } - return y; - } - template void calculateTrkEff(T1 const& trackPos1, T2 const& trackPos2, McPart const& mcParticles) { @@ -399,7 +403,7 @@ struct HfCorrelatorLcScHadrons { continue; auto chargeTrack = pdg->GetParticle(track.pdgCode())->Charge(); // Retrieve charge - registry.fill(HIST("hPtTracksVsSignGen"), track.pt(), chargeTrack / (2 * std::abs(chargeTrack))); + registry.fill(HIST("hPtTracksVsSignGen"), track.pt(), chargeTrack / (std::abs(chargeTrack))); } } template @@ -599,6 +603,7 @@ struct HfCorrelatorLcScHadrons { if (selLcPKPi) { registry.fill(HIST("hMassLcVsPt"), massCandPKPi, ptCand, efficiencyWeightCand); + registry.fill(HIST("hMassScVsPtVsSign"), massCandPKPi, ptCand, chargeCand, efficiencyWeightCand); registry.fill(HIST("hMassLcData"), massCandPKPi, efficiencyWeightCand); registry.fill(HIST("hSelectionStatusLcToPKPi"), selLcPKPi); if (isPrompt) { @@ -619,6 +624,7 @@ struct HfCorrelatorLcScHadrons { if (selLcPiKP) { registry.fill(HIST("hMassLcVsPt"), massCandPiKP, ptCand, efficiencyWeightCand); + registry.fill(HIST("hMassScVsPtVsSign"), massCandPKPi, ptCand, chargeCand, efficiencyWeightCand); registry.fill(HIST("hMassLcData"), massCandPiKP, efficiencyWeightCand); registry.fill(HIST("hSelectionStatusLcToPiKP"), selLcPiKP); if (isPrompt) { @@ -678,9 +684,9 @@ struct HfCorrelatorLcScHadrons { if (std::abs(motherTrk.pdgCode()) == kLambdaCPlus) continue; - registry.fill(HIST("hPtTracksVsSignRec"), track.pt(), track.sign() / 2.); + registry.fill(HIST("hPtTracksVsSignRec"), track.pt(), track.sign()); if (std::abs(mcParticle.pdgCode()) == kProton) - registry.fill(HIST("hPtTracksVsSignRecTrue"), track.pt(), track.sign() / 2.); + registry.fill(HIST("hPtTracksVsSignRecTrue"), track.pt(), track.sign()); } } @@ -827,10 +833,140 @@ struct HfCorrelatorLcScHadrons { } } + template + void doSameEventMcGen(CollisionType const& mcCollision, PartType const& mcParticles){ + + int counterCharmCand = 0; + registry.fill(HIST("hMcEvtCount"), 0); + BinningTypeMcGen corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true}; + poolBin = corrBinningMcGen.getBin(std::make_tuple(mcCollision.posZ(), mcCollision.multMCFT0A())); + registry.fill(HIST("hMultFT0AMcGen"), mcCollision.multMCFT0A()); + + // find leading particle + if (correlateLcWithLeadingParticle) { + leadingIndex = findLeadingParticleMcGen(mcParticles, etaTrackMax.value, ptTrackMin.value); + } + // Mc Gen level + for (const auto& particle : mcParticles) { + + double massCand = -999.0; + bool isCandFound = isCandSc ? matchCandAndMass(particle, massCand) : + matchCandAndMass(particle, massCand); + if (!isCandFound){ + continue; + } + double yCand = RecoDecay::y(particle.pVector(), massCand); + + if (std::abs(yCand) > yCandGenMax || particle.pt() < ptCandMin) { + continue; + } + registry.fill(HIST("hCandBin"), poolBin); + registry.fill(HIST("hPtCandMcGen"), particle.pt()); + registry.fill(HIST("hEtaMcGen"), particle.eta()); + registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); + registry.fill(HIST("hYMcGen"), yCand); + + int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge + if (chargeLc != 0){ + chargeLc = chargeLc / std::abs(chargeLc); + } + + isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; + isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; + if (isPrompt) { + registry.fill(HIST("hPtCandMcGenPrompt"), particle.pt()); + registry.fill(HIST("hPtCandVsChargeMcGenPrompt"), particle.pt(), chargeLc); + } else if (isNonPrompt) { + registry.fill(HIST("hPtCandMcGenNonPrompt"), particle.pt()); + registry.fill(HIST("hPtCandVsChargeMcGenNonPrompt"), particle.pt(), chargeLc); + } + + static constexpr size_t NDaughtersSc{4u}; + static constexpr size_t NDaughtersLc{3u}; + std::vector listDaughters{}; + listDaughters.clear(); + const size_t expectedDaughters = isCandSc ? 4 : 3; + + if (isCandSc){ + if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0){ + std::array arrDaughSc0PDG = {kProton, -kKPlus, kPiPlus, kPiMinus}; + RecoDecay::getDaughters(particle, &listDaughters, arrDaughSc0PDG, 2); + } else { + std::array arrDaughScPlusPDG = {kProton, -kKPlus, kPiPlus, kPiPlus}; + RecoDecay::getDaughters(particle, &listDaughters, arrDaughScPlusPDG, 2); + } + } else { + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); + } + + int counterDaughters = 0; + std::vector prongsId(expectedDaughters); + if (listDaughters.size() == expectedDaughters) { + for (const auto& dauIdx : listDaughters) { + auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); + counterDaughters += 1; + prongsId[counterDaughters - 1] = daughI.globalIndex(); + } + } + counterCharmCand++; + + // Lc Hadron correlation dedicated section + // if it's a Lc particle, search for Hadron and evalutate correlations + registry.fill(HIST("hcountCandtriggersMcGen"), 0, particle.pt()); // to count trigger Lc for normalisation + for (const auto& particleAssoc : mcParticles) { + if (std::abs(particleAssoc.eta()) > etaTrackMax || particleAssoc.pt() < ptTrackMin || particleAssoc.pt() > ptTrackMax) { + continue; + } + + if (std::find(prongsId.begin(), prongsId.end(), particleAssoc.globalIndex()) != prongsId.end()) { + if (!storeAutoCorrelationFlag) { + continue; + } + correlationStatus = true; + } + + if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { + continue; + } + + if (pidTrkApplied && (std::abs(particleAssoc.pdgCode()) != kProton)) + continue; // proton PID + + if (!particleAssoc.isPhysicalPrimary()) { + continue; + } + + if (correlateLcWithLeadingParticle) { + if (particleAssoc.globalIndex() != leadingIndex) { + continue; + } + } + + int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, particleAssoc, true); + int8_t chargeAssoc = pdg->GetParticle(particleAssoc.pdgCode())->Charge(); // Retrieve charge + chargeAssoc = chargeAssoc / std::abs(chargeAssoc); + registry.fill(HIST("hPtParticleAssocMcGen"), particleAssoc.pt()); + entryCandHadronPair(getDeltaPhi(particleAssoc.phi(), particle.phi()), + particleAssoc.eta() - particle.eta(), + particle.pt(), + particleAssoc.pt() * chargeAssoc, + poolBin, + correlationStatus); + entryCandHadronPairY(particleAssoc.y() - yCand); + entryCandHadronRecoInfo(massCand, true); + entryCandHadronGenInfo(isPrompt, particleAssoc.isPhysicalPrimary(), trackOrigin); + entryPairCandCharge(chargeLc); + } // end inner loop + } // end outer loop + registry.fill(HIST("hcountCandHadronPerEvent"), counterCharmCand); + registry.fill(HIST("hZvtx"), mcCollision.posZ()); + } + //} /// Lc-hadron correlation pair builder - for real data and data-like analysis (i.e. reco-level w/o matching request via MC truth) - void processDataLc(SelCollisionsWithLc::iterator const& collision, + void processDataLc(SelCollisions::iterator const& collision, TracksData const& tracks, CandsLcDataFiltered const& candidates, aod::BCsWithTimestamps const&) @@ -839,7 +975,7 @@ struct HfCorrelatorLcScHadrons { } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataLc, "Process data", true); - void processDataSc(SelCollisionsWithSc::iterator const& collision, + void processDataSc(SelCollisions::iterator const& collision, TracksData const& tracks, aod::Tracks const&, aod::HfCandSc const& candidates, @@ -851,7 +987,7 @@ struct HfCorrelatorLcScHadrons { PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataSc, "Process data Sc", false); /// Lc-Hadron correlation process starts for McRec - void processMcRecLc(SelCollisionsWithLc::iterator const& collision, + void processMcRecLc(SelCollisions::iterator const& collision, TracksWithMc const& tracks, CandsLcMcRecFiltered const& candidates, aod::McParticles const& mcParticles) @@ -861,11 +997,10 @@ struct HfCorrelatorLcScHadrons { PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecLc, "Process Mc Reco mode", false); /// Lc-Hadron correlation process starts for McRec - void processMcRecSc(SelCollisionsWithSc::iterator const& collision, + void processMcRecSc(SelCollisions::iterator const& collision, TracksWithMc const& tracks, aod::TracksWMc const&, - soa::Join const& candidates, + CandsScMcRec const& candidates, CandsLcData const&, aod::McParticles const& mcParticles) { @@ -873,7 +1008,7 @@ struct HfCorrelatorLcScHadrons { } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcRecSc, "Process Mc Reco mode", false); - void processDataMixedEventSc(SelCollisionsWithSc const& collisions, + void processDataMixedEventSc(SelCollisions const& collisions, TracksData const& tracks, aod::Tracks const&, aod::HfCandSc const& candidates, @@ -883,7 +1018,7 @@ struct HfCorrelatorLcScHadrons { } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataMixedEventSc, "Process Mixed Event Data", false); - void processDataMixedEventLc(SelCollisionsWithLc const& collisions, + void processDataMixedEventLc(SelCollisions const& collisions, CandsLcDataFiltered const& candidates, TracksData const& tracks) { @@ -892,7 +1027,7 @@ struct HfCorrelatorLcScHadrons { } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processDataMixedEventLc, "Process Mixed Event Data", false); - void processMcRecMixedEventSc(SelCollisionsWithSc const& collisions, + void processMcRecMixedEventSc(SelCollisions const& collisions, TracksWithMc const& tracks, aod::TracksWMc const&, soa::Join yCandGenMax || particle.pt() < ptCandMin) { - continue; - } - registry.fill(HIST("hCandBin"), poolBin); - registry.fill(HIST("hPtCandMcGen"), particle.pt()); - registry.fill(HIST("hEtaMcGen"), particle.eta()); - registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); - registry.fill(HIST("hYMcGen"), yL); - - isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; - isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; - if (isPrompt) { - registry.fill(HIST("hPtCandMcGenPrompt"), particle.pt()); - } else if (isNonPrompt) { - registry.fill(HIST("hPtCandMcGenNonPrompt"), particle.pt()); - } - - // prompt and non-prompt division - std::vector listDaughters{}; - std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; - std::array prongsId; - listDaughters.clear(); - RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); - int counterDaughters = 0; - if (listDaughters.size() == NDaughters) { - for (const auto& dauIdx : listDaughters) { - auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); - counterDaughters += 1; - prongsId[counterDaughters - 1] = daughI.globalIndex(); - } - } - counterLcHadron++; - // Lc Hadron correlation dedicated section - // if it's a Lc particle, search for Hadron and evalutate correlations - registry.fill(HIST("hcountCandtriggersMcGen"), 0, particle.pt()); // to count trigger Lc for normalisation - for (const auto& particleAssoc : mcParticles) { - if (std::abs(particleAssoc.eta()) > etaTrackMax || particleAssoc.pt() < ptTrackMin || particleAssoc.pt() > ptTrackMax) { - continue; - } - if (particleAssoc.globalIndex() == prongsId[0] || particleAssoc.globalIndex() == prongsId[1] || particleAssoc.globalIndex() == prongsId[2]) { - if (!storeAutoCorrelationFlag) { - continue; - } - correlationStatus = true; - } - - if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { - continue; - } - - if (pidTrkApplied && (std::abs(particleAssoc.pdgCode()) != kProton)) - continue; // proton PID - - if (!particleAssoc.isPhysicalPrimary()) { - continue; - } - - if (correlateLcWithLeadingParticle) { - if (particleAssoc.globalIndex() != leadingIndex) { - continue; - } - } - - int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge - int8_t chargeAssoc = pdg->GetParticle(particleAssoc.pdgCode())->Charge(); // Retrieve charge + doSameEventMcGen(mcCollision, mcParticles); + } + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGenLc, "Process Mc Gen Lc mode", false); - int trackOrigin = RecoDecay::getCharmHadronOrigin(mcParticles, particleAssoc, true); - registry.fill(HIST("hPtParticleAssocMcGen"), particleAssoc.pt()); - entryCandHadronPair(getDeltaPhi(particleAssoc.phi(), particle.phi()), - particleAssoc.eta() - particle.eta(), - particle.pt() * chargeLc / std::abs(chargeLc), - particleAssoc.pt() * chargeAssoc / std::abs(chargeAssoc), - poolBin, - correlationStatus); - entryCandHadronPairY(particleAssoc.y() - yL); - entryCandHadronRecoInfo(MassLambdaCPlus, true); - entryCandHadronGenInfo(isPrompt, particleAssoc.isPhysicalPrimary(), trackOrigin); - } // end inner loop - } // end outer loop - registry.fill(HIST("hcountCandHadronPerEvent"), counterLcHadron); - registry.fill(HIST("hZvtx"), mcCollision.posZ()); + void processMcGenSc(SelCollisionsMc::iterator const& mcCollision, + CandidatesScMcGen const& mcParticles) + { + doSameEventMcGen(mcCollision, mcParticles); } - PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGen, "Process Mc Gen mode", false); + PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGenSc, "Process Mc Gen Sc mode", false); - void processMcGenMixedEvent(SelCollisionsWithLcMc const& collisions, + void processMcGenMixedEvent(SelCollisionsMc const& collisions, CandidatesLcMcGen const& mcParticles) { BinningTypeMcGen corrBinningMcGen{{binsZVtx, binsMultiplicityMc}, true}; auto tracksTuple = std::make_tuple(mcParticles, mcParticles); - Pair pairMcGen{corrBinningMcGen, numberEventsMixed, -1, collisions, tracksTuple, &cache}; + Pair pairMcGen{corrBinningMcGen, numberEventsMixed, -1, collisions, tracksTuple, &cache}; for (const auto& [c1, tracks1, c2, tracks2] : pairMcGen) { poolBin = corrBinningMcGen.getBin(std::make_tuple(c1.posZ(), c1.multMCFT0A())); for (const auto& [candidate, particleAssoc] : o2::soa::combinations(o2::soa::CombinationsFullIndexPolicy(tracks1, tracks2))) { From 2e34d62a31ebed3cb4381f5e7619d01c5c6a6690 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 18 Jun 2025 20:37:27 +0200 Subject: [PATCH 19/35] PWGHF: added processes to filter Sc collisions --- PWGHF/HFC/Utils/utilsCorrelations.h | 72 +++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index 90f7b8524d9..ce0104321a4 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -28,6 +28,10 @@ #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/PIDResponseTOF.h" +using namespace o2::constants::physics; + +HfHelper hfHelper; + namespace o2::analysis::hf_correlations { enum Region { @@ -119,6 +123,74 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, return true; // Passed all checks } +template +bool matchCandAndMass(McParticle const& particle, double& massCand) { + const auto pdgCand = std::abs(particle.pdgCode()); + const auto matchGenFlag = std::abs(particle.flagMcMatchGen()); + + // Validate PDG code based on candidate type + if constexpr (isScCand) { + if (!(pdgCand == Pdg::kSigmaC0 || + pdgCand == Pdg::kSigmaCPlusPlus || + pdgCand == Pdg::kSigmaCStar0 || + pdgCand == Pdg::kSigmaCStarPlusPlus)) { + return false; + } + } else { + if (pdgCand != Pdg::kLambdaCPlus) { + return false; + } + } + //std::cout< + double estimateY(CandType const& candidate) + { + double y = -999.; + const int chargeScZero = 0; + if constexpr (isCandSc) { + int8_t chargeCand = candidate.charge(); + + if (chargeCand == chargeScZero) { + y = hfHelper.ySc0(candidate); + } else { + y = hfHelper.yScPlusPlus(candidate); + } + + } else { + y = hfHelper.yLc(candidate); + } + return y; + } + // ========= Find Leading Particle ============== template //// FIXME: 14 days int findLeadingParticle(TTracks const& tracks, T1 const etaTrackMax) From 27c3d092828259211b50469810a0b9d61f644a3e Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 18 Jun 2025 20:41:55 +0200 Subject: [PATCH 20/35] PWGHF: Added processes to filter Sc collisions --- PWGHF/HFC/Utils/utilsCorrelations.h | 1 - 1 file changed, 1 deletion(-) diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index ce0104321a4..ac874858c64 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -141,7 +141,6 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) { return false; } } - //std::cout< Date: Wed, 18 Jun 2025 18:43:22 +0000 Subject: [PATCH 21/35] Please consider the following formatting changes --- .../TableProducer/correlatorLcScHadrons.cxx | 70 +++++++++---------- PWGHF/HFC/Utils/utilsCorrelations.h | 36 +++++----- 2 files changed, 53 insertions(+), 53 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index d90a673eca0..689d1ffd6db 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -92,7 +92,7 @@ struct HfCorrelatorLcScHadronsSelection { for (const auto& candidate : candidates) { auto yCand = estimateY(candidate); - + if (std::abs(yCand) > yCandMax || candidate.pt() < ptCandMin) { isCandFound = false; continue; @@ -119,7 +119,7 @@ struct HfCorrelatorLcScHadronsSelection { for (const auto& particle : mcParticles) { isCandFound = matchCandAndMass(particle, massCand); - if (!isCandFound){ + if (!isCandFound) { continue; } @@ -137,31 +137,31 @@ struct HfCorrelatorLcScHadronsSelection { /// Code to select collisions with at least one Lc - for real data and data-like analysis void processLcSelection(SelCollisions::iterator const& collision, - CandsLcDataFiltered const& candidates) + CandsLcDataFiltered const& candidates) { - selectionCollision(collision,candidates); + selectionCollision(collision, candidates); } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelection, "Process Lc Collision Selection for Data and Mc", true); - void processScSelection(SelCollisions::iterator const& collision, - aod::HfCandSc const& candidates) + void processScSelection(SelCollisions::iterator const& collision, + aod::HfCandSc const& candidates) { - selectionCollision(collision,candidates); + selectionCollision(collision, candidates); } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelection, "Process Sc Collision Selection for Data and Mc", false); - void processLcSelectionMcRec(SelCollisions::iterator const& collision, + void processLcSelectionMcRec(SelCollisions::iterator const& collision, CandsLcMcRecFiltered const& candidates) { - selectionCollision(collision,candidates); + selectionCollision(collision, candidates); } -PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); void processScSelectionMcRec(SelCollisions::iterator const& collision, - CandsScMcRec const& candidates) - { - selectionCollision(collision,candidates); - } + CandsScMcRec const& candidates) + { + selectionCollision(collision, candidates); + } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelectionMcRec, "Process Sc Selection McRec", false); void processLcSelectionMcGen(aod::McCollision const&, @@ -241,12 +241,12 @@ struct HfCorrelatorLcScHadrons { bool isSignal = false; TRandom3* rnd = new TRandom3(0); - //std::vector outputMl = {-1., -1., -1.}; + // std::vector outputMl = {-1., -1., -1.}; std::vector outputMlPKPi = {-1., -1., -1.}; std::vector outputMlPiKP = {-1., -1., -1.}; // Event Mixing for the Data Mode - //using SelCollisionsWithSc = soa::Join; + // using SelCollisionsWithSc = soa::Join; using SelCollisions = soa::Filtered>; using SelCollisionsMc = soa::Filtered>; // collisionFilter applied @@ -834,7 +834,8 @@ struct HfCorrelatorLcScHadrons { } template - void doSameEventMcGen(CollisionType const& mcCollision, PartType const& mcParticles){ + void doSameEventMcGen(CollisionType const& mcCollision, PartType const& mcParticles) + { int counterCharmCand = 0; registry.fill(HIST("hMcEvtCount"), 0); @@ -850,9 +851,8 @@ struct HfCorrelatorLcScHadrons { for (const auto& particle : mcParticles) { double massCand = -999.0; - bool isCandFound = isCandSc ? matchCandAndMass(particle, massCand) : - matchCandAndMass(particle, massCand); - if (!isCandFound){ + bool isCandFound = isCandSc ? matchCandAndMass(particle, massCand) : matchCandAndMass(particle, massCand); + if (!isCandFound) { continue; } double yCand = RecoDecay::y(particle.pVector(), massCand); @@ -866,10 +866,10 @@ struct HfCorrelatorLcScHadrons { registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); registry.fill(HIST("hYMcGen"), yCand); - int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge - if (chargeLc != 0){ - chargeLc = chargeLc / std::abs(chargeLc); - } + int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge + if (chargeLc != 0) { + chargeLc = chargeLc / std::abs(chargeLc); + } isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; @@ -887,8 +887,8 @@ struct HfCorrelatorLcScHadrons { listDaughters.clear(); const size_t expectedDaughters = isCandSc ? 4 : 3; - if (isCandSc){ - if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0){ + if (isCandSc) { + if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0) { std::array arrDaughSc0PDG = {kProton, -kKPlus, kPiPlus, kPiMinus}; RecoDecay::getDaughters(particle, &listDaughters, arrDaughSc0PDG, 2); } else { @@ -896,10 +896,10 @@ struct HfCorrelatorLcScHadrons { RecoDecay::getDaughters(particle, &listDaughters, arrDaughScPlusPDG, 2); } } else { - std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; - RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); } - + int counterDaughters = 0; std::vector prongsId(expectedDaughters); if (listDaughters.size() == expectedDaughters) { @@ -921,9 +921,9 @@ struct HfCorrelatorLcScHadrons { if (std::find(prongsId.begin(), prongsId.end(), particleAssoc.globalIndex()) != prongsId.end()) { if (!storeAutoCorrelationFlag) { - continue; - } - correlationStatus = true; + continue; + } + correlationStatus = true; } if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { @@ -1050,14 +1050,14 @@ struct HfCorrelatorLcScHadrons { /// Lc-Hadron correlation pair builder - for Mc Gen-level analysis void processMcGenLc(SelCollisionsMc::iterator const& mcCollision, - CandidatesLcMcGen const& mcParticles) + CandidatesLcMcGen const& mcParticles) { doSameEventMcGen(mcCollision, mcParticles); } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGenLc, "Process Mc Gen Lc mode", false); - void processMcGenSc(SelCollisionsMc::iterator const& mcCollision, - CandidatesScMcGen const& mcParticles) + void processMcGenSc(SelCollisionsMc::iterator const& mcCollision, + CandidatesScMcGen const& mcParticles) { doSameEventMcGen(mcCollision, mcParticles); } diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index ac874858c64..932ee5ad595 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -124,7 +124,8 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, } template -bool matchCandAndMass(McParticle const& particle, double& massCand) { +bool matchCandAndMass(McParticle const& particle, double& massCand) +{ const auto pdgCand = std::abs(particle.pdgCode()); const auto matchGenFlag = std::abs(particle.flagMcMatchGen()); @@ -155,7 +156,7 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) { case BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi): massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; - + case BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi): massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; @@ -169,26 +170,25 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) { } } +template +double estimateY(CandType const& candidate) +{ + double y = -999.; + const int chargeScZero = 0; + if constexpr (isCandSc) { + int8_t chargeCand = candidate.charge(); - template - double estimateY(CandType const& candidate) - { - double y = -999.; - const int chargeScZero = 0; - if constexpr (isCandSc) { - int8_t chargeCand = candidate.charge(); - - if (chargeCand == chargeScZero) { - y = hfHelper.ySc0(candidate); - } else { - y = hfHelper.yScPlusPlus(candidate); - } - + if (chargeCand == chargeScZero) { + y = hfHelper.ySc0(candidate); } else { - y = hfHelper.yLc(candidate); + y = hfHelper.yScPlusPlus(candidate); } - return y; + + } else { + y = hfHelper.yLc(candidate); } + return y; +} // ========= Find Leading Particle ============== template //// FIXME: 14 days From 2aead6d355d56722492f8c54a4357d2adc9ba9df Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Thu, 19 Jun 2025 00:27:05 +0200 Subject: [PATCH 22/35] [PWGHF: Added processes to select Sc collisions --- PWGHF/HFC/Utils/utilsCorrelations.h | 47 +++++++++-------------------- 1 file changed, 14 insertions(+), 33 deletions(-) diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index 932ee5ad595..af77bd4c124 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -28,9 +28,7 @@ #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/PIDResponseTOF.h" -using namespace o2::constants::physics; - -HfHelper hfHelper; +//HfHelper hfHelper; namespace o2::analysis::hf_correlations { @@ -49,12 +47,16 @@ enum PairSign { LcNegTrkNeg }; +constexpr float PhiTowardMax{o2::constants::math::PIThird}; +constexpr float PhiAwayMin{2.f * o2::constants::math::PIThird}; +constexpr float PhiAwayMax{4.f * o2::constants::math::PIThird}; + template Region getRegion(T const deltaPhi) { - if (std::abs(deltaPhi) < o2::constants::math::PIThird) { + if (std::abs(deltaPhi) < PhiTowardMax) { return Toward; - } else if (deltaPhi > 2. * o2::constants::math::PIThird && deltaPhi < 4. * o2::constants::math::PIThird) { + } else if (deltaPhi > PhiAwayMin && deltaPhi < PhiAwayMax) { return Away; } else { return Transverse; @@ -124,21 +126,20 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, } template -bool matchCandAndMass(McParticle const& particle, double& massCand) -{ +bool matchCandAndMass(McParticle const& particle, double& massCand) { const auto pdgCand = std::abs(particle.pdgCode()); const auto matchGenFlag = std::abs(particle.flagMcMatchGen()); // Validate PDG code based on candidate type if constexpr (isScCand) { - if (!(pdgCand == Pdg::kSigmaC0 || - pdgCand == Pdg::kSigmaCPlusPlus || - pdgCand == Pdg::kSigmaCStar0 || - pdgCand == Pdg::kSigmaCStarPlusPlus)) { + if (!(pdgCand == o2::constants::physics::Pdg::kSigmaC0 || + pdgCand == o2::constants::physics::Pdg::kSigmaCPlusPlus || + pdgCand == o2::constants::physics::Pdg::kSigmaCStar0 || + pdgCand == o2::constants::physics::Pdg::kSigmaCStarPlusPlus)) { return false; } } else { - if (pdgCand != Pdg::kLambdaCPlus) { + if (pdgCand != o2::constants::physics::Pdg::kLambdaCPlus) { return false; } } @@ -156,7 +157,7 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) case BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi): massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; - + case BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi): massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; @@ -170,26 +171,6 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) } } -template -double estimateY(CandType const& candidate) -{ - double y = -999.; - const int chargeScZero = 0; - if constexpr (isCandSc) { - int8_t chargeCand = candidate.charge(); - - if (chargeCand == chargeScZero) { - y = hfHelper.ySc0(candidate); - } else { - y = hfHelper.yScPlusPlus(candidate); - } - - } else { - y = hfHelper.yLc(candidate); - } - return y; -} - // ========= Find Leading Particle ============== template //// FIXME: 14 days int findLeadingParticle(TTracks const& tracks, T1 const etaTrackMax) From 5269d07faaf230c0782c5d15abe0ab8eee955819 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Thu, 19 Jun 2025 00:28:23 +0200 Subject: [PATCH 23/35] PWGHF: Added processes to select Sc collisions --- .../TableProducer/correlatorLcScHadrons.cxx | 103 ++++++++++++------ 1 file changed, 68 insertions(+), 35 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 689d1ffd6db..5629f9a14a7 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -88,11 +88,24 @@ struct HfCorrelatorLcScHadronsSelection { bool isCandFound = false; bool isSel8 = true; bool isNosameBunchPileUp = true; + double yCand = -999.; + const int chargeScZero = 0; if (doSelLcCollision) { for (const auto& candidate : candidates) { - auto yCand = estimateY(candidate); + if constexpr (isCandSc) { + int8_t chargeCand = candidate.charge(); + if (chargeCand == chargeScZero) { + yCand = hfHelper.ySc0(candidate); + } else { + yCand = hfHelper.yScPlusPlus(candidate); + } + + } else { + yCand = hfHelper.yLc(candidate); + } + if (std::abs(yCand) > yCandMax || candidate.pt() < ptCandMin) { isCandFound = false; continue; @@ -119,7 +132,7 @@ struct HfCorrelatorLcScHadronsSelection { for (const auto& particle : mcParticles) { isCandFound = matchCandAndMass(particle, massCand); - if (!isCandFound) { + if (!isCandFound){ continue; } @@ -137,31 +150,31 @@ struct HfCorrelatorLcScHadronsSelection { /// Code to select collisions with at least one Lc - for real data and data-like analysis void processLcSelection(SelCollisions::iterator const& collision, - CandsLcDataFiltered const& candidates) + CandsLcDataFiltered const& candidates) { - selectionCollision(collision, candidates); + selectionCollision(collision,candidates); } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelection, "Process Lc Collision Selection for Data and Mc", true); - void processScSelection(SelCollisions::iterator const& collision, - aod::HfCandSc const& candidates) + void processScSelection(SelCollisions::iterator const& collision, + aod::HfCandSc const& candidates) { - selectionCollision(collision, candidates); + selectionCollision(collision,candidates); } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelection, "Process Sc Collision Selection for Data and Mc", false); - void processLcSelectionMcRec(SelCollisions::iterator const& collision, + void processLcSelectionMcRec(SelCollisions::iterator const& collision, CandsLcMcRecFiltered const& candidates) { - selectionCollision(collision, candidates); + selectionCollision(collision,candidates); } - PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); +PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); void processScSelectionMcRec(SelCollisions::iterator const& collision, - CandsScMcRec const& candidates) - { - selectionCollision(collision, candidates); - } + CandsScMcRec const& candidates) + { + selectionCollision(collision,candidates); + } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelectionMcRec, "Process Sc Selection McRec", false); void processLcSelectionMcGen(aod::McCollision const&, @@ -241,12 +254,12 @@ struct HfCorrelatorLcScHadrons { bool isSignal = false; TRandom3* rnd = new TRandom3(0); - // std::vector outputMl = {-1., -1., -1.}; + //std::vector outputMl = {-1., -1., -1.}; std::vector outputMlPKPi = {-1., -1., -1.}; std::vector outputMlPiKP = {-1., -1., -1.}; // Event Mixing for the Data Mode - // using SelCollisionsWithSc = soa::Join; + //using SelCollisionsWithSc = soa::Join; using SelCollisions = soa::Filtered>; using SelCollisionsMc = soa::Filtered>; // collisionFilter applied @@ -370,6 +383,26 @@ struct HfCorrelatorLcScHadrons { } }; + template + double estimateY(CandType const& candidate) + { + double y = -999.; + const int chargeScZero = 0; + if constexpr (isCandSc) { + int8_t chargeCand = candidate.charge(); + + if (chargeCand == chargeScZero) { + y = hfHelper.ySc0(candidate); + } else { + y = hfHelper.yScPlusPlus(candidate); + } + + } else { + y = hfHelper.yLc(candidate); + } + return y; + } + template void calculateTrkEff(T1 const& trackPos1, T2 const& trackPos2, McPart const& mcParticles) { @@ -834,8 +867,7 @@ struct HfCorrelatorLcScHadrons { } template - void doSameEventMcGen(CollisionType const& mcCollision, PartType const& mcParticles) - { + void doSameEventMcGen(CollisionType const& mcCollision, PartType const& mcParticles){ int counterCharmCand = 0; registry.fill(HIST("hMcEvtCount"), 0); @@ -851,8 +883,9 @@ struct HfCorrelatorLcScHadrons { for (const auto& particle : mcParticles) { double massCand = -999.0; - bool isCandFound = isCandSc ? matchCandAndMass(particle, massCand) : matchCandAndMass(particle, massCand); - if (!isCandFound) { + bool isCandFound = isCandSc ? matchCandAndMass(particle, massCand) : + matchCandAndMass(particle, massCand); + if (!isCandFound){ continue; } double yCand = RecoDecay::y(particle.pVector(), massCand); @@ -866,10 +899,10 @@ struct HfCorrelatorLcScHadrons { registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); registry.fill(HIST("hYMcGen"), yCand); - int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge - if (chargeLc != 0) { - chargeLc = chargeLc / std::abs(chargeLc); - } + int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge + if (chargeLc != 0){ + chargeLc = chargeLc / std::abs(chargeLc); + } isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; @@ -887,8 +920,8 @@ struct HfCorrelatorLcScHadrons { listDaughters.clear(); const size_t expectedDaughters = isCandSc ? 4 : 3; - if (isCandSc) { - if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0) { + if (isCandSc){ + if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0){ std::array arrDaughSc0PDG = {kProton, -kKPlus, kPiPlus, kPiMinus}; RecoDecay::getDaughters(particle, &listDaughters, arrDaughSc0PDG, 2); } else { @@ -896,10 +929,10 @@ struct HfCorrelatorLcScHadrons { RecoDecay::getDaughters(particle, &listDaughters, arrDaughScPlusPDG, 2); } } else { - std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; - RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); } - + int counterDaughters = 0; std::vector prongsId(expectedDaughters); if (listDaughters.size() == expectedDaughters) { @@ -921,9 +954,9 @@ struct HfCorrelatorLcScHadrons { if (std::find(prongsId.begin(), prongsId.end(), particleAssoc.globalIndex()) != prongsId.end()) { if (!storeAutoCorrelationFlag) { - continue; - } - correlationStatus = true; + continue; + } + correlationStatus = true; } if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { @@ -1050,14 +1083,14 @@ struct HfCorrelatorLcScHadrons { /// Lc-Hadron correlation pair builder - for Mc Gen-level analysis void processMcGenLc(SelCollisionsMc::iterator const& mcCollision, - CandidatesLcMcGen const& mcParticles) + CandidatesLcMcGen const& mcParticles) { doSameEventMcGen(mcCollision, mcParticles); } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGenLc, "Process Mc Gen Lc mode", false); - void processMcGenSc(SelCollisionsMc::iterator const& mcCollision, - CandidatesScMcGen const& mcParticles) + void processMcGenSc(SelCollisionsMc::iterator const& mcCollision, + CandidatesScMcGen const& mcParticles) { doSameEventMcGen(mcCollision, mcParticles); } From 3c3881e4d438307990a4caaea1ac821cba7e43c8 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Wed, 18 Jun 2025 22:28:49 +0000 Subject: [PATCH 24/35] Please consider the following formatting changes --- .../TableProducer/correlatorLcScHadrons.cxx | 90 +++++++++---------- PWGHF/HFC/Utils/utilsCorrelations.h | 7 +- 2 files changed, 49 insertions(+), 48 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 5629f9a14a7..95ff7d0217f 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -93,19 +93,19 @@ struct HfCorrelatorLcScHadronsSelection { if (doSelLcCollision) { for (const auto& candidate : candidates) { - if constexpr (isCandSc) { - int8_t chargeCand = candidate.charge(); + if constexpr (isCandSc) { + int8_t chargeCand = candidate.charge(); - if (chargeCand == chargeScZero) { - yCand = hfHelper.ySc0(candidate); - } else { - yCand = hfHelper.yScPlusPlus(candidate); - } + if (chargeCand == chargeScZero) { + yCand = hfHelper.ySc0(candidate); + } else { + yCand = hfHelper.yScPlusPlus(candidate); + } + + } else { + yCand = hfHelper.yLc(candidate); + } - } else { - yCand = hfHelper.yLc(candidate); - } - if (std::abs(yCand) > yCandMax || candidate.pt() < ptCandMin) { isCandFound = false; continue; @@ -132,7 +132,7 @@ struct HfCorrelatorLcScHadronsSelection { for (const auto& particle : mcParticles) { isCandFound = matchCandAndMass(particle, massCand); - if (!isCandFound){ + if (!isCandFound) { continue; } @@ -150,31 +150,31 @@ struct HfCorrelatorLcScHadronsSelection { /// Code to select collisions with at least one Lc - for real data and data-like analysis void processLcSelection(SelCollisions::iterator const& collision, - CandsLcDataFiltered const& candidates) + CandsLcDataFiltered const& candidates) { - selectionCollision(collision,candidates); + selectionCollision(collision, candidates); } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelection, "Process Lc Collision Selection for Data and Mc", true); - void processScSelection(SelCollisions::iterator const& collision, - aod::HfCandSc const& candidates) + void processScSelection(SelCollisions::iterator const& collision, + aod::HfCandSc const& candidates) { - selectionCollision(collision,candidates); + selectionCollision(collision, candidates); } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelection, "Process Sc Collision Selection for Data and Mc", false); - void processLcSelectionMcRec(SelCollisions::iterator const& collision, + void processLcSelectionMcRec(SelCollisions::iterator const& collision, CandsLcMcRecFiltered const& candidates) { - selectionCollision(collision,candidates); + selectionCollision(collision, candidates); } -PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); + PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processLcSelectionMcRec, "Process Lc Selection McRec", false); void processScSelectionMcRec(SelCollisions::iterator const& collision, - CandsScMcRec const& candidates) - { - selectionCollision(collision,candidates); - } + CandsScMcRec const& candidates) + { + selectionCollision(collision, candidates); + } PROCESS_SWITCH(HfCorrelatorLcScHadronsSelection, processScSelectionMcRec, "Process Sc Selection McRec", false); void processLcSelectionMcGen(aod::McCollision const&, @@ -254,12 +254,12 @@ struct HfCorrelatorLcScHadrons { bool isSignal = false; TRandom3* rnd = new TRandom3(0); - //std::vector outputMl = {-1., -1., -1.}; + // std::vector outputMl = {-1., -1., -1.}; std::vector outputMlPKPi = {-1., -1., -1.}; std::vector outputMlPiKP = {-1., -1., -1.}; // Event Mixing for the Data Mode - //using SelCollisionsWithSc = soa::Join; + // using SelCollisionsWithSc = soa::Join; using SelCollisions = soa::Filtered>; using SelCollisionsMc = soa::Filtered>; // collisionFilter applied @@ -867,7 +867,8 @@ struct HfCorrelatorLcScHadrons { } template - void doSameEventMcGen(CollisionType const& mcCollision, PartType const& mcParticles){ + void doSameEventMcGen(CollisionType const& mcCollision, PartType const& mcParticles) + { int counterCharmCand = 0; registry.fill(HIST("hMcEvtCount"), 0); @@ -883,9 +884,8 @@ struct HfCorrelatorLcScHadrons { for (const auto& particle : mcParticles) { double massCand = -999.0; - bool isCandFound = isCandSc ? matchCandAndMass(particle, massCand) : - matchCandAndMass(particle, massCand); - if (!isCandFound){ + bool isCandFound = isCandSc ? matchCandAndMass(particle, massCand) : matchCandAndMass(particle, massCand); + if (!isCandFound) { continue; } double yCand = RecoDecay::y(particle.pVector(), massCand); @@ -899,10 +899,10 @@ struct HfCorrelatorLcScHadrons { registry.fill(HIST("hPhiMcGen"), RecoDecay::constrainAngle(particle.phi(), -PIHalf)); registry.fill(HIST("hYMcGen"), yCand); - int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge - if (chargeLc != 0){ - chargeLc = chargeLc / std::abs(chargeLc); - } + int8_t chargeLc = pdg->GetParticle(particle.pdgCode())->Charge(); // Retrieve charge + if (chargeLc != 0) { + chargeLc = chargeLc / std::abs(chargeLc); + } isPrompt = particle.originMcGen() == RecoDecay::OriginType::Prompt; isNonPrompt = particle.originMcGen() == RecoDecay::OriginType::NonPrompt; @@ -920,8 +920,8 @@ struct HfCorrelatorLcScHadrons { listDaughters.clear(); const size_t expectedDaughters = isCandSc ? 4 : 3; - if (isCandSc){ - if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0){ + if (isCandSc) { + if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0) { std::array arrDaughSc0PDG = {kProton, -kKPlus, kPiPlus, kPiMinus}; RecoDecay::getDaughters(particle, &listDaughters, arrDaughSc0PDG, 2); } else { @@ -929,10 +929,10 @@ struct HfCorrelatorLcScHadrons { RecoDecay::getDaughters(particle, &listDaughters, arrDaughScPlusPDG, 2); } } else { - std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; - RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); } - + int counterDaughters = 0; std::vector prongsId(expectedDaughters); if (listDaughters.size() == expectedDaughters) { @@ -954,9 +954,9 @@ struct HfCorrelatorLcScHadrons { if (std::find(prongsId.begin(), prongsId.end(), particleAssoc.globalIndex()) != prongsId.end()) { if (!storeAutoCorrelationFlag) { - continue; - } - correlationStatus = true; + continue; + } + correlationStatus = true; } if ((std::abs(particleAssoc.pdgCode()) != kElectron) && (std::abs(particleAssoc.pdgCode()) != kMuonMinus) && (std::abs(particleAssoc.pdgCode()) != kPiPlus) && (std::abs(particle.pdgCode()) != kKPlus) && (std::abs(particleAssoc.pdgCode()) != kProton)) { @@ -1083,14 +1083,14 @@ struct HfCorrelatorLcScHadrons { /// Lc-Hadron correlation pair builder - for Mc Gen-level analysis void processMcGenLc(SelCollisionsMc::iterator const& mcCollision, - CandidatesLcMcGen const& mcParticles) + CandidatesLcMcGen const& mcParticles) { doSameEventMcGen(mcCollision, mcParticles); } PROCESS_SWITCH(HfCorrelatorLcScHadrons, processMcGenLc, "Process Mc Gen Lc mode", false); - void processMcGenSc(SelCollisionsMc::iterator const& mcCollision, - CandidatesScMcGen const& mcParticles) + void processMcGenSc(SelCollisionsMc::iterator const& mcCollision, + CandidatesScMcGen const& mcParticles) { doSameEventMcGen(mcCollision, mcParticles); } diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index af77bd4c124..61e91710344 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -28,7 +28,7 @@ #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/PIDResponseTOF.h" -//HfHelper hfHelper; +// HfHelper hfHelper; namespace o2::analysis::hf_correlations { @@ -126,7 +126,8 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, } template -bool matchCandAndMass(McParticle const& particle, double& massCand) { +bool matchCandAndMass(McParticle const& particle, double& massCand) +{ const auto pdgCand = std::abs(particle.pdgCode()); const auto matchGenFlag = std::abs(particle.flagMcMatchGen()); @@ -157,7 +158,7 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) { case BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi): massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; - + case BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi): massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; From 93a772f0494d1f9f4fc73892ca7572a1ae898500 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Thu, 19 Jun 2025 17:14:14 +0200 Subject: [PATCH 25/35] PWGHF: Added processes to select Sc collisions with comments implimented --- PWGHF/HFC/Utils/utilsCorrelations.h | 23 ++++++++++++++--------- 1 file changed, 14 insertions(+), 9 deletions(-) diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index 61e91710344..a52000bb110 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -28,8 +28,6 @@ #include "Common/DataModel/PIDResponseTPC.h" #include "Common/DataModel/PIDResponseTOF.h" -// HfHelper hfHelper; - namespace o2::analysis::hf_correlations { enum Region { @@ -125,6 +123,7 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, return true; // Passed all checks } +//function to select candidate based on PDF and decay channels and their mass template bool matchCandAndMass(McParticle const& particle, double& massCand) { @@ -132,7 +131,7 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) const auto matchGenFlag = std::abs(particle.flagMcMatchGen()); // Validate PDG code based on candidate type - if constexpr (isScCand) { + if (isScCand) { if (!(pdgCand == o2::constants::physics::Pdg::kSigmaC0 || pdgCand == o2::constants::physics::Pdg::kSigmaCPlusPlus || pdgCand == o2::constants::physics::Pdg::kSigmaCStar0 || @@ -147,28 +146,34 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) // Map decay type to mass switch (matchGenFlag) { - case BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi): + case BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi):{ massCand = o2::constants::physics::MassSigmaC0; return true; + } - case BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi): + case BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi):{ massCand = o2::constants::physics::MassSigmaCStar0; return true; + } - case BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi): + case BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi):{ massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; + } - case BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi): + case BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi):{ massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; + } - case hf_decay::hf_cand_3prong::DecayChannelMain::LcToPKPi: + case hf_decay::hf_cand_3prong::DecayChannelMain::LcToPKPi:{ massCand = o2::constants::physics::MassLambdaCPlus; return true; + } - default: + default:{ return false; + } } } From e981b859cadd4d0384e30c14c8c6c19488d3a336 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Thu, 19 Jun 2025 17:16:33 +0200 Subject: [PATCH 26/35] PW --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 95ff7d0217f..7722c385d68 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -914,11 +914,11 @@ struct HfCorrelatorLcScHadrons { registry.fill(HIST("hPtCandVsChargeMcGenNonPrompt"), particle.pt(), chargeLc); } - static constexpr size_t NDaughtersSc{4u}; - static constexpr size_t NDaughtersLc{3u}; + static constexpr std::size_t NDaughtersSc{4u}; + static constexpr std::size_t NDaughtersLc{3u}; std::vector listDaughters{}; listDaughters.clear(); - const size_t expectedDaughters = isCandSc ? 4 : 3; + const std::size_t nDaughtersExpected = isCandSc ? 4 : 3; if (isCandSc) { if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0) { @@ -934,8 +934,8 @@ struct HfCorrelatorLcScHadrons { } int counterDaughters = 0; - std::vector prongsId(expectedDaughters); - if (listDaughters.size() == expectedDaughters) { + std::vector prongsId(nDaughtersExpected); + if (listDaughters.size() == nDaughtersExpected) { for (const auto& dauIdx : listDaughters) { auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); counterDaughters += 1; From f02034bd1d3c53ebf357f22e462ee96927478701 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Thu, 19 Jun 2025 15:16:58 +0000 Subject: [PATCH 27/35] Please consider the following formatting changes --- PWGHF/HFC/Utils/utilsCorrelations.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index a52000bb110..d2f0ac49736 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -123,7 +123,7 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, return true; // Passed all checks } -//function to select candidate based on PDF and decay channels and their mass +// function to select candidate based on PDF and decay channels and their mass template bool matchCandAndMass(McParticle const& particle, double& massCand) { @@ -146,32 +146,32 @@ bool matchCandAndMass(McParticle const& particle, double& massCand) // Map decay type to mass switch (matchGenFlag) { - case BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi):{ + case BIT(aod::hf_cand_sigmac::DecayType::Sc0ToPKPiPi): { massCand = o2::constants::physics::MassSigmaC0; return true; } - case BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi):{ + case BIT(aod::hf_cand_sigmac::DecayType::ScStar0ToPKPiPi): { massCand = o2::constants::physics::MassSigmaCStar0; return true; } - case BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi):{ + case BIT(aod::hf_cand_sigmac::DecayType::ScplusplusToPKPiPi): { massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; } - case BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi):{ + case BIT(aod::hf_cand_sigmac::DecayType::ScStarPlusPlusToPKPiPi): { massCand = o2::constants::physics::MassSigmaCStarPlusPlus; return true; } - case hf_decay::hf_cand_3prong::DecayChannelMain::LcToPKPi:{ + case hf_decay::hf_cand_3prong::DecayChannelMain::LcToPKPi: { massCand = o2::constants::physics::MassLambdaCPlus; return true; } - default:{ + default: { return false; } } From bb36ffd1c5f380e843ec42b35e925d7bd24c32c4 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 24 Jun 2025 09:58:07 +0200 Subject: [PATCH 28/35] added doxygen documentation for the function matchCandAndMass and fixed typename --- PWGHF/HFC/Utils/utilsCorrelations.h | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index d2f0ac49736..a206833a4fe 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -123,15 +123,25 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, return true; // Passed all checks } -// function to select candidate based on PDF and decay channels and their mass -template -bool matchCandAndMass(McParticle const& particle, double& massCand) +/// @brief Selects a candidate based on its PDG code, decay channel, and assigns the corresponding mass. +/// +/// @tparam isScCandidate Boolean template parameter: +/// - `true` to check for Sigma_c candidates +/// - `false` to check for Lambda_c candidates +/// @tparam McParticleType Type representing the MC particle, must provide `pdgCode()` and `flagMcMatchGen()` +/// +/// @param[in] particle MC particle whose PDG code and decay flag are evaluated +/// @param[out] massCand Mass of the matched candidate is set here, if a valid match is found +/// +/// @return `true` if candidate matches expected PDG and decay flag, and mass is set; `false` otherwise +template +bool matchCandAndMass(McParticleType const& particle, double& massCand) { const auto pdgCand = std::abs(particle.pdgCode()); const auto matchGenFlag = std::abs(particle.flagMcMatchGen()); // Validate PDG code based on candidate type - if (isScCand) { + if (isScCandidate) { if (!(pdgCand == o2::constants::physics::Pdg::kSigmaC0 || pdgCand == o2::constants::physics::Pdg::kSigmaCPlusPlus || pdgCand == o2::constants::physics::Pdg::kSigmaCStar0 || From a7561aa3b2e6a3c4f11144355d701a037969c80f Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 24 Jun 2025 07:58:38 +0000 Subject: [PATCH 29/35] Please consider the following formatting changes --- PWGHF/HFC/Utils/utilsCorrelations.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/HFC/Utils/utilsCorrelations.h b/PWGHF/HFC/Utils/utilsCorrelations.h index a206833a4fe..b830eedcfef 100644 --- a/PWGHF/HFC/Utils/utilsCorrelations.h +++ b/PWGHF/HFC/Utils/utilsCorrelations.h @@ -124,8 +124,8 @@ bool passPIDSelection(Atrack const& track, SpeciesContainer const mPIDspecies, } /// @brief Selects a candidate based on its PDG code, decay channel, and assigns the corresponding mass. -/// -/// @tparam isScCandidate Boolean template parameter: +/// +/// @tparam isScCandidate Boolean template parameter: /// - `true` to check for Sigma_c candidates /// - `false` to check for Lambda_c candidates /// @tparam McParticleType Type representing the MC particle, must provide `pdgCode()` and `flagMcMatchGen()` From 8d49e1db95c43a8f298b1cc34f1708bb9f1addb5 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 24 Jun 2025 18:45:17 +0200 Subject: [PATCH 30/35] removed magic number and fixed rapidy bug --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 7722c385d68..68f6e42a3c6 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -453,7 +453,7 @@ struct HfCorrelatorLcScHadrons { track.pt() * track.sign(), binPool, correlStatus); - entryCandHadronPairY(track.y() - yCand); + entryCandHadronPairY(track.rapidity(MassProton) - yCand); entryCandHadronMlInfo(outMl[0], outMl[1]); entryTrackRecoInfo(track.dcaXY(), track.dcaZ(), track.tpcNClsCrossedRows()); entryPairCandCharge(signCand); @@ -918,7 +918,7 @@ struct HfCorrelatorLcScHadrons { static constexpr std::size_t NDaughtersLc{3u}; std::vector listDaughters{}; listDaughters.clear(); - const std::size_t nDaughtersExpected = isCandSc ? 4 : 3; + const std::size_t nDaughtersExpected = isCandSc ? NDaughtersSc : NDaughtersLc; if (isCandSc) { if (massCand == o2::constants::physics::MassSigmaC0 || massCand == o2::constants::physics::MassSigmaCStar0) { From fed4efe33f72d3eb840ce52816d1f7769bddd869 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 24 Jun 2025 20:14:14 +0200 Subject: [PATCH 31/35] PWGHF: fixed rapidity bug for proton --- PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx index c76ec3d62d2..e1b4fece38e 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx @@ -441,7 +441,7 @@ struct HfCorrelatorLcHadrons { track.pt() * track.sign(), poolBin, correlationStatus); - entryLcHadronPairY(track.y() - hfHelper.yLc(candidate)); + entryLcHadronPairY(track.rapidity(MassProton) - hfHelper.yLc(candidate)); // only for proton as of now entryLcHadronRecoInfo(hfHelper.invMassLcToPKPi(candidate), false); entryLcHadronGenInfo(false, false, 0); entryLcHadronMlInfo(outputMl[0], outputMl[1]); @@ -457,7 +457,7 @@ struct HfCorrelatorLcHadrons { track.pt() * track.sign(), poolBin, correlationStatus); - entryLcHadronPairY(track.y() - hfHelper.yLc(candidate)); + entryLcHadronPairY(track.rapidity(MassProton) - hfHelper.yLc(candidate)); // only for proton as of now entryLcHadronRecoInfo(hfHelper.invMassLcToPiKP(candidate), false); entryLcHadronGenInfo(false, false, 0); entryLcHadronMlInfo(outputMl[0], outputMl[1]); @@ -694,7 +694,7 @@ struct HfCorrelatorLcHadrons { track.pt() * track.sign(), poolBin, correlationStatus); - entryLcHadronPairY(track.y() - hfHelper.yLc(candidate)); + entryLcHadronPairY(track.rapidity(MassProton) - hfHelper.yLc(candidate)); // only for proton as of now entryLcHadronRecoInfo(hfHelper.invMassLcToPKPi(candidate), isLcSignal); if (fillTrkPID) { entryLcHadronPairTrkPID(track.tpcNSigmaPr(), track.tpcNSigmaKa(), track.tpcNSigmaPi(), track.tofNSigmaPr(), track.tofNSigmaKa(), track.tofNSigmaPi()); @@ -724,7 +724,7 @@ struct HfCorrelatorLcHadrons { track.pt() * track.sign(), poolBin, correlationStatus); - entryLcHadronPairY(track.y() - hfHelper.yLc(candidate)); + entryLcHadronPairY(track.rapidity(MassProton) - hfHelper.yLc(candidate)); // only for proton as of now entryLcHadronRecoInfo(hfHelper.invMassLcToPiKP(candidate), isLcSignal); if (fillTrkPID) { entryLcHadronPairTrkPID(track.tpcNSigmaPr(), track.tpcNSigmaKa(), track.tpcNSigmaPi(), track.tofNSigmaPr(), track.tofNSigmaKa(), track.tofNSigmaPi()); From a5eb1508c088d8a24aab50918fc5e4a7613b45b0 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Tue, 24 Jun 2025 20:22:39 +0200 Subject: [PATCH 32/35] PWGHF: fixed rapidity bug for proton --- PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx index e1b4fece38e..6895a431402 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx @@ -211,7 +211,7 @@ struct HfCorrelatorLcHadrons { Service pdg; int leadingIndex = 0; bool correlationStatus = false; - static constexpr size_t nDaughters{3u}; + static constexpr size_t NDaughters{3u}; TRandom3* rnd = new TRandom3(0); // Event Mixing for the Data Mode @@ -801,12 +801,12 @@ struct HfCorrelatorLcHadrons { // prompt and non-prompt division std::vector listDaughters{}; - std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; - std::array prongsId; + std::array arrDaughLcPDG = {kProton, -kKPlus, kPiPlus}; + std::array prongsId; listDaughters.clear(); RecoDecay::getDaughters(particle, &listDaughters, arrDaughLcPDG, 2); int counterDaughters = 0; - if (listDaughters.size() == nDaughters) { + if (listDaughters.size() == NDaughters) { for (const auto& dauIdx : listDaughters) { auto daughI = mcParticles.rawIteratorAt(dauIdx - mcParticles.offset()); counterDaughters += 1; From e246c92752e8fa5a9e914cd0aab33341a48c4a4b Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 25 Jun 2025 22:23:30 +0200 Subject: [PATCH 33/35] PWGHF: Fixed issue in mixed event process of disabled cache Tracks/fIndexCollisions --- PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx index 6895a431402..9bcc06fbd3c 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx @@ -232,8 +232,10 @@ struct HfCorrelatorLcHadrons { Filter lcFilter = ((o2::aod::hf_track_index::hfflag & static_cast(1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) != static_cast(0)) && (aod::hf_sel_candidate_lc::isSelLcToPKPi >= selectionFlagLc || aod::hf_sel_candidate_lc::isSelLcToPiKP >= selectionFlagLc); Filter trackFilter = (nabs(aod::track::eta) < etaTrackMax) && (nabs(aod::track::pt) > ptTrackMin) && (nabs(aod::track::dcaXY) < dcaXYTrackMax) && (nabs(aod::track::dcaZ) < dcaZTrackMax); - // Preslice perTrueCollision = o2::aod::mcparticle::McCollisionId; Preslice perTrueCollision = o2::aod::mcparticle::mcCollisionId; + Preslice perCollisionID = aod::track::collisionId; + Preslice cand3ProngPerCol = aod::hf_cand::collisionId; + // configurable axis definition ConfigurableAxis binsMultiplicity{"binsMultiplicity", {VARIABLE_WIDTH, 0.0f, 2000.0f, 6000.0f, 100000.0f}, "Mixing bins - multiplicity"}; ConfigurableAxis binsZVtx{"binsZVtx", {VARIABLE_WIDTH, -10.0f, -2.5f, 2.5f, 10.0f}, "Mixing bins - z-vertex"}; From 595aa31dcec0d995a76cf04820d05dcc4e89ac3d Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Wed, 25 Jun 2025 22:29:05 +0200 Subject: [PATCH 34/35] PWGHF: Fixed issue in mixed event process of disabled cache Tracks/fIndexCollisions --- PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx index 68f6e42a3c6..21d3b4b6458 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcScHadrons.cxx @@ -283,8 +283,11 @@ struct HfCorrelatorLcScHadrons { Filter lcFilter = ((o2::aod::hf_track_index::hfflag & static_cast(1 << aod::hf_cand_3prong::DecayType::LcToPKPi)) != static_cast(0)) && (aod::hf_sel_candidate_lc::isSelLcToPKPi >= selectionFlagLc || aod::hf_sel_candidate_lc::isSelLcToPiKP >= selectionFlagLc); Filter trackFilter = (nabs(aod::track::eta) < etaTrackMax) && (nabs(aod::track::pt) > ptTrackMin) && (nabs(aod::track::dcaXY) < dcaXYTrackMax) && (nabs(aod::track::dcaZ) < dcaZTrackMax); - // Preslice perTrueCollision = o2::aod::mcparticle::McCollisionId; Preslice perTrueCollision = o2::aod::mcparticle::mcCollisionId; + Preslice perCollisionID = aod::track::collisionId; + Preslice cand3ProngPerCol = aod::hf_cand::collisionId; + Preslice csndScPerCol = aod::hf_cand::collisionId; + // configurable axis definition ConfigurableAxis binsMultiplicity{"binsMultiplicity", {VARIABLE_WIDTH, 0.0f, 2000.0f, 6000.0f, 100000.0f}, "Mixing bins - multiplicity"}; ConfigurableAxis binsZVtx{"binsZVtx", {VARIABLE_WIDTH, -10.0f, -2.5f, 2.5f, 10.0f}, "Mixing bins - z-vertex"}; From cec2523417d894cc404345e6c76495c34fb59883 Mon Sep 17 00:00:00 2001 From: Ravindra Singh <56298081+singhra1994@users.noreply.github.com> Date: Thu, 26 Jun 2025 14:33:21 +0200 Subject: [PATCH 35/35] added std while using size_t MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Vít Kučera --- PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx index 9bcc06fbd3c..7dc6d877a8b 100644 --- a/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx +++ b/PWGHF/HFC/TableProducer/correlatorLcHadrons.cxx @@ -211,7 +211,7 @@ struct HfCorrelatorLcHadrons { Service pdg; int leadingIndex = 0; bool correlationStatus = false; - static constexpr size_t NDaughters{3u}; + static constexpr std::size_t NDaughters{3u}; TRandom3* rnd = new TRandom3(0); // Event Mixing for the Data Mode