From cc3e168447b2de28550920c55771fe675d7516e6 Mon Sep 17 00:00:00 2001 From: Prottay Das Date: Fri, 12 Jun 2026 17:16:39 +0200 Subject: [PATCH 1/3] data model for phi reconstruction for flow --- PWGLF/DataModel/LFPhiFlowTables.h | 78 ++++ PWGLF/TableProducer/Resonances/CMakeLists.txt | 5 + PWGLF/TableProducer/Resonances/phiflow.cxx | 377 ++++++++++++++++++ 3 files changed, 460 insertions(+) create mode 100644 PWGLF/DataModel/LFPhiFlowTables.h create mode 100644 PWGLF/TableProducer/Resonances/phiflow.cxx diff --git a/PWGLF/DataModel/LFPhiFlowTables.h b/PWGLF/DataModel/LFPhiFlowTables.h new file mode 100644 index 00000000000..fe3f27bd642 --- /dev/null +++ b/PWGLF/DataModel/LFPhiFlowTables.h @@ -0,0 +1,78 @@ +// 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 LFPhiFlowTables.h +/// \brief DataModel for Phi flow +/// +/// \author Prottay Das + +#ifndef PWGLF_DATAMODEL_LFPHIFLOW_H_ +#define PWGLF_DATAMODEL_LFPHIFLOW_H_ + +#include +#include + +#include +#include + +namespace o2::aod +{ +namespace kaonkaonevent +{ +DECLARE_SOA_COLUMN(Cent, cent, float); +DECLARE_SOA_COLUMN(Posz, posz, float); +DECLARE_SOA_COLUMN(QxA, qxA, float); +DECLARE_SOA_COLUMN(QxC, qxC, float); +DECLARE_SOA_COLUMN(QyA, qyA, float); +DECLARE_SOA_COLUMN(QyC, qyC, float); +} // namespace kaonkaonevent +DECLARE_SOA_TABLE(KaonkaonEvents, "AOD", "KAONKAONEVENT", + o2::soa::Index<>, + kaonkaonevent::Cent, + kaonkaonevent::Posz, + kaonkaonevent::QxA, + kaonkaonevent::QxC, + kaonkaonevent::QyA, + kaonkaonevent::QyC) +using KaonkaonEvent = KaonkaonEvents::iterator; + +namespace kaonkaonpair +{ +DECLARE_SOA_INDEX_COLUMN(KaonkaonEvent, kaonkaonevent); +DECLARE_SOA_COLUMN(D1Px, d1Px, float); //! Bachelor Kaon Px +DECLARE_SOA_COLUMN(D1Py, d1Py, float); //! Bachelor Kaon Py +DECLARE_SOA_COLUMN(D1Pz, d1Pz, float); //! Bachelor Kaon Pz +DECLARE_SOA_COLUMN(D2Px, d2Px, float); //! Bachelor Kaon Px +DECLARE_SOA_COLUMN(D2Py, d2Py, float); //! Bachelor Kaon Py +DECLARE_SOA_COLUMN(D2Pz, d2Pz, float); //! Bachelor Kaon Pz +DECLARE_SOA_COLUMN(PhiM, phiM, float); //! Phi Mass +DECLARE_SOA_COLUMN(KaonIndex1, kaonIndex1, int); //! Daughter Kaon index1 +DECLARE_SOA_COLUMN(KaonIndex2, kaonIndex2, int); //! Daughter Kaon index2 +DECLARE_SOA_COLUMN(KaonPidMask, kaonPidMask, uint16_t); //! bitmask for PID selections +} // namespace kaonkaonpair + +DECLARE_SOA_TABLE(KaonTracks, "AOD", "KAONTRACK", + o2::soa::Index<>, + kaonkaonpair::KaonkaonEventId, + kaonkaonpair::D1Px, + kaonkaonpair::D1Py, + kaonkaonpair::D1Pz, + kaonkaonpair::D2Px, + kaonkaonpair::D2Py, + kaonkaonpair::D2Pz, + kaonkaonpair::PhiM, + kaonkaonpair::KaonIndex1, + kaonkaonpair::KaonIndex2, + kaonkaonpair::KaonPidMask); + +using KaonTrack = KaonTracks::iterator; +} // namespace o2::aod +#endif // PWGLF_DATAMODEL_LFPHIFLOW_H_ diff --git a/PWGLF/TableProducer/Resonances/CMakeLists.txt b/PWGLF/TableProducer/Resonances/CMakeLists.txt index a3e59673293..05e51ad1511 100644 --- a/PWGLF/TableProducer/Resonances/CMakeLists.txt +++ b/PWGLF/TableProducer/Resonances/CMakeLists.txt @@ -55,6 +55,11 @@ o2physics_add_dpl_workflow(cksspinalignment PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore COMPONENT_NAME Analysis) +o2physics_add_dpl_workflow(phiflow + SOURCES phiflow.cxx + PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore + COMPONENT_NAME Analysis) + o2physics_add_dpl_workflow(resonance-tree-creator SOURCES resonanceTreeCreator.cxx PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore diff --git a/PWGLF/TableProducer/Resonances/phiflow.cxx b/PWGLF/TableProducer/Resonances/phiflow.cxx new file mode 100644 index 00000000000..04c157a1272 --- /dev/null +++ b/PWGLF/TableProducer/Resonances/phiflow.cxx @@ -0,0 +1,377 @@ +// 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 phiflow.cxx +/// \brief Table producer for Phi FLow +/// +/// \author prottay.das@cern.ch + +#include "PWGLF/DataModel/LFPhiFlowTables.h" +#include "PWGLF/DataModel/SPCalibrationTables.h" + +#include "Common/CCDB/EventSelectionParams.h" +#include "Common/CCDB/RCTSelectionFlags.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/PIDResponseITS.h" +#include "Common/DataModel/PIDResponseTOF.h" +#include "Common/DataModel/PIDResponseTPC.h" +#include "Common/DataModel/TrackSelectionTables.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include // IWYU pragma: keep (do not replace with Math/Vector4Dfwd.h) +#include + +#include +#include +#include +#include +#include + +using namespace o2; +using namespace o2::framework; +using namespace o2::framework::expressions; +using namespace o2::aod::rctsel; + +struct phiflow { + + Produces kaonkaonEvent; + Produces kaonTrack; + + Service ccdb; + + struct : ConfigurableGroup { + Configurable requireRCTFlagChecker{"requireRCTFlagChecker", true, "Check event quality in run condition table"}; + Configurable cfgEvtRCTFlagCheckerLabel{"cfgEvtRCTFlagCheckerLabel", "CBT_hadronPID", "Evt sel: RCT flag checker label"}; + Configurable cfgEvtRCTFlagCheckerZDCCheck{"cfgEvtRCTFlagCheckerZDCCheck", false, "Evt sel: RCT flag checker ZDC check"}; + Configurable cfgEvtRCTFlagCheckerLimitAcceptAsBad{"cfgEvtRCTFlagCheckerLimitAcceptAsBad", true, "Evt sel: RCT flag checker treat Limited Acceptance As Bad"}; + } rctCut; + + Configurable useNoCollInTimeRangeStandard{"useNoCollInTimeRangeStandard", false, "Apply kNoCollInTimeRangeStandard selection bit"}; + Configurable useGoodITSLayersAll{"useGoodITSLayersAll", true, "Apply kIsGoodITSLayersAll selection bit"}; + Configurable cfgCutOccupancy{"cfgCutOccupancy", 2000, "Occupancy cut"}; + + // events + Configurable cfgCutVertex{"cfgCutVertex", 10.0f, "Accepted z-vertex range"}; + Configurable cfgCutCentralityMax{"cfgCutCentralityMax", 80.0f, "Accepted maximum Centrality"}; + Configurable cfgCutCentralityMin{"cfgCutCentralityMin", 0.0f, "Accepted minimum Centrality"}; + + // Configs for track filtering + Configurable cfgCutCharge{"cfgCutCharge", 0.0, "Charge cut on daughter"}; + Configurable cfgCutPt{"cfgCutPt", 0.2, "Pt cut on daughter track"}; + Configurable cfgCutEta{"cfgCutEta", 0.8, "Eta cut on daughter track"}; + Configurable cfgCutDCAxy{"cfgCutDCAxy", 0.2, "DCAxy cut on daughter track"}; + Configurable cfgCutDCAz{"cfgCutDCAz", 0.2, "DCAz cut on daughter track"}; + Configurable nsigmaCutTPC{"nsigmaCutTPC", 3.0, "Maximum nsigma cut TPC for filtered kaon track"}; + + // Configs for kaon + struct : ConfigurableGroup { + Configurable itsPIDSelection{"itsPIDSelection", true, "PID ITS"}; + Configurable lowITSPIDNsigma{"lowITSPIDNsigma", -3.0, "lower cut on PID nsigma for ITS"}; + Configurable highITSPIDNsigma{"highITSPIDNsigma", 3.0, "higher cut on PID nsigma for ITS"}; + Configurable itsclusterKaMeson{"itsclusterKaMeson", 5, "Minimum number of ITS cluster for kaon meson track"}; + Configurable tpcCrossedRowsKaMeson{"tpcCrossedRowsKaMeson", 80, "Minimum number of TPC Crossed Rows for kaon meson track"}; + Configurable cutDCAxyKaMeson{"cutDCAxyKaMeson", 0.1, "Maximum DCAxy for kaon meson track"}; + Configurable cutDCAzKaMeson{"cutDCAzKaMeson", 0.1, "Maximum DCAz for kaon meson track"}; + Configurable cutEtaKaMeson{"cutEtaKaMeson", 0.8, "Maximum eta for kaon meson track"}; + Configurable cutPTKaMeson{"cutPTKaMeson", 0.8, "Minimum pt for kaon meson track"}; + Configurable usePID{"usePID", true, "Flag for using PID selection for kaon meson track"}; + Configurable nsigmaCutTPCKaMeson{"nsigmaCutTPCKaMeson", 3.0, "Maximum nsigma cut TPC for kaon meson track"}; + Configurable nsigmaCutTOFKaMeson{"nsigmaCutTOFKaMeson", 3.0, "Maximum nsigma cut TOF for kaon meson track"}; + Configurable cutTOFBetaKaMeson{"cutTOFBetaKaMeson", 1.0, "Maximum beta cut for kaon meson track"}; + Configurable isDeepAngle{"isDeepAngle", true, "Deep Angle cut"}; + Configurable cutDeepAngle{"cutDeepAngle", 0.04, "Deep Angle cut value"}; + } grpKaon; + + enum KaonPidBits : uint8_t { + kPID1 = 1u << 0, // selectionPID + kPID2 = 1u << 1, // selectionPID2 + kPID3 = 1u << 2, // selectionPID3 + kPID4 = 1u << 3 // selectionPID4 + }; + + // configurable for chargedkstar + Configurable cfgPhiMassMin{"cfgPhiMassMin", 0.9f, "Phi mass min"}; + Configurable cfgPhiMassMax{"cfgPhiMassMax", 1.2f, "Phi mass max"}; + + Configurable iMNbins{"iMNbins", 120, "Number of bins in invariant mass"}; + Configurable lbinIM{"lbinIM", 0.9, "lower bin value in IM histograms"}; + Configurable hbinIM{"hbinIM", 1.2, "higher bin value in IM histograms"}; + + HistogramRegistry histos{"histos", {}, OutputObjHandlingPolicy::AnalysisObject}; + RCTFlagsChecker rctChecker; + void init(o2::framework::InitContext&) + { + rctChecker.init(rctCut.cfgEvtRCTFlagCheckerLabel, rctCut.cfgEvtRCTFlagCheckerZDCCheck, rctCut.cfgEvtRCTFlagCheckerLimitAcceptAsBad); + AxisSpec thnAxisInvMass{iMNbins, lbinIM, hbinIM, "#it{M} (GeV/#it{c}^{2})"}; + + histos.add("hCent", "hCent", kTH1F, {{8, 0, 80.0}}); + histos.add("hEvtSelInfo", "hEvtSelInfo", kTH1F, {{5, 0, 5.0}}); + histos.add("hTrkSelInfo", "hTrkSelInfo", kTH1F, {{10, 0, 10.0}}); + histos.add("hPhiMass", "hPhiMass", kTH1F, {thnAxisInvMass}); + histos.add("hInfo", "hInfo", kTH1F, {{5, 0, 5.0}}); + } + + template + bool selectionTrack(const T& candidate) + { + if (candidate.isGlobalTrack() && candidate.isPVContributor() && candidate.itsNCls() >= grpKaon.itsclusterKaMeson && candidate.tpcNClsCrossedRows() > grpKaon.tpcCrossedRowsKaMeson && std::abs(candidate.dcaXY()) <= grpKaon.cutDCAxyKaMeson && std::abs(candidate.dcaZ()) <= grpKaon.cutDCAzKaMeson && std::abs(candidate.eta()) <= grpKaon.cutEtaKaMeson && candidate.pt() >= grpKaon.cutPTKaMeson) { + return true; + } + return false; + } + + template + bool selectionPID(const T& candidate) + { + if (!candidate.hasTOF() && std::abs(candidate.tpcNSigmaKa()) < grpKaon.nsigmaCutTPCKaMeson) { + return true; + } + if (candidate.hasTOF() && candidate.beta() > grpKaon.cutTOFBetaKaMeson && std::abs(candidate.tpcNSigmaKa()) < grpKaon.nsigmaCutTPCKaMeson && std::abs(candidate.tofNSigmaKa()) < grpKaon.nsigmaCutTOFKaMeson) { + return true; + } + return false; + } + + template + bool selectionPID2(const T& candidate) + { + if (!candidate.hasTOF() && std::abs(candidate.tpcNSigmaKa()) < grpKaon.nsigmaCutTPCKaMeson) { + return true; + } + if (candidate.hasTOF() && candidate.beta() > grpKaon.cutTOFBetaKaMeson && std::sqrt(candidate.tpcNSigmaKa() * candidate.tpcNSigmaKa() + candidate.tofNSigmaKa() * candidate.tofNSigmaKa()) < grpKaon.nsigmaCutTOFKaMeson) { + return true; + } + return false; + } + + template + bool selectionPID3(const T& candidate) + { + auto px = candidate.px(); + auto py = candidate.py(); + auto pt = std::sqrt(px * px + py * py); + float lowmom = 0.5; + if (pt < lowmom) { + if (!candidate.hasTOF() && std::abs(candidate.tpcNSigmaKa()) < grpKaon.nsigmaCutTPCKaMeson) { + return true; + } else if (candidate.hasTOF() && std::sqrt(candidate.tpcNSigmaKa() * candidate.tpcNSigmaKa() + candidate.tofNSigmaKa() * candidate.tofNSigmaKa()) < grpKaon.nsigmaCutTOFKaMeson) { + return true; + } + } else if (candidate.hasTOF() && std::sqrt(candidate.tpcNSigmaKa() * candidate.tpcNSigmaKa() + candidate.tofNSigmaKa() * candidate.tofNSigmaKa()) < grpKaon.nsigmaCutTOFKaMeson) { + return true; + } + return false; + } + + template + bool selectionPID4(const T& candidate) + { + const float px = candidate.px(); + const float py = candidate.py(); + // const float pz = candidate.pz(); + const float pt = std::sqrt(px * px + py * py); + + constexpr float pSwitch = 0.5f; // GeV/c + + const float nTPC = candidate.tpcNSigmaKa(); + + // Low momentum: TPC-only, TOF not required and not used + if (pt < pSwitch) { + return std::abs(nTPC) < grpKaon.nsigmaCutTPCKaMeson; // e.g. 3 + } + + // High momentum: TOF hit mandatory + separate 3σ cuts + if (!candidate.hasTOF()) { + return false; + } + + const float nTOF = candidate.tofNSigmaKa(); + return (std::abs(nTPC) < grpKaon.nsigmaCutTPCKaMeson) && + (std::abs(nTOF) < grpKaon.nsigmaCutTOFKaMeson); + } + + template + uint8_t kaonPidMask(const T& trk) + { + uint8_t m = 0; + if (selectionPID(trk)) + m |= kPID1; + if (selectionPID2(trk)) + m |= kPID2; + if (selectionPID3(trk)) + m |= kPID3; + if (selectionPID4(trk)) + m |= kPID4; + return m; + } + + // deep angle cut on pair to remove photon conversion + template + bool selectionPair(const T1& candidate1, const T2& candidate2) + { + double pt1, pt2, pz1, pz2, p1, p2, angle; + pt1 = candidate1.pt(); + pt2 = candidate2.pt(); + pz1 = candidate1.pz(); + pz2 = candidate2.pz(); + p1 = candidate1.p(); + p2 = candidate2.p(); + angle = TMath::ACos((pt1 * pt2 + pz1 * pz2) / (p1 * p2)); + if (grpKaon.isDeepAngle && angle < grpKaon.cutDeepAngle) { + return false; + } + return true; + } + + ROOT::Math::PxPyPzMVector phi, kaon, antiKaon; + + Filter collisionFilter = nabs(aod::collision::posZ) < cfgCutVertex; + Filter centralityFilter = (aod::cent::centFT0C < cfgCutCentralityMax && aod::cent::centFT0C > cfgCutCentralityMin); + Filter acceptanceFilter = (nabs(aod::track::eta) < cfgCutEta && (aod::track::pt) > cfgCutPt); + Filter DCAcutFilter = (nabs(aod::track::dcaXY) < cfgCutDCAxy) && (nabs(aod::track::dcaZ) < cfgCutDCAz); + Filter PIDcutFilter = nabs(aod::pidtpc::tpcNSigmaKa) < nsigmaCutTPC; + + using EventCandidates = soa::Filtered>; + using AllTrackCandidates = soa::Filtered>; + SliceCache cache; + Partition posTracks = aod::track::signed1Pt > cfgCutCharge; + Partition negTracks = aod::track::signed1Pt < cfgCutCharge; + + ROOT::Math::PxPyPzMVector KaonPlus, KaonMinus, PhiMesonMother, PhiVectorDummy, Phid1dummy, Phid2dummy; + double massKa = o2::constants::physics::MassKPlus; + + void processData(EventCandidates::iterator const& collision, AllTrackCandidates const& tracks) + { + o2::aod::ITSResponse itsResponse; + int numberPhi = 0; + auto centrality = collision.centFT0C(); + auto vz = collision.posZ(); + int occupancy = collision.trackOccupancyInTimeRange(); + auto qxZDCA = collision.qxZDCA(); + auto qxZDCC = collision.qxZDCC(); + auto qyZDCA = collision.qyZDCA(); + auto qyZDCC = collision.qyZDCC(); + + std::vector phiresonance, phiresonanced1, phiresonanced2; + std::vector Phid1Index = {}; + std::vector Phid2Index = {}; + std::vector PhiPairPidMask = {}; + + histos.fill(HIST("hEvtSelInfo"), 0.5); + if ((!rctCut.requireRCTFlagChecker || rctChecker(collision)) && collision.selection_bit(aod::evsel::kNoSameBunchPileup) && collision.selection_bit(aod::evsel::kIsGoodZvtxFT0vsPV) && (!useNoCollInTimeRangeStandard || collision.selection_bit(o2::aod::evsel::kNoCollInTimeRangeStandard)) && collision.sel8() && (!useGoodITSLayersAll || collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) && occupancy < cfgCutOccupancy) { + histos.fill(HIST("hEvtSelInfo"), 1.5); + auto posThisColl = posTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + auto negThisColl = negTracks->sliceByCached(aod::track::collisionId, collision.globalIndex(), cache); + + histos.fill(HIST("hCent"), centrality); + + for (const auto& track1 : posThisColl) { + histos.fill(HIST("hTrkSelInfo"), 0.5); + if (!selectionTrack(track1)) { + continue; + } + histos.fill(HIST("hTrkSelInfo"), 1.5); + + if (grpKaon.itsPIDSelection && !(itsResponse.nSigmaITS(track1) > grpKaon.lowITSPIDNsigma && itsResponse.nSigmaITS(track1) < grpKaon.highITSPIDNsigma)) { + continue; + } + histos.fill(HIST("hTrkSelInfo"), 2.5); + const uint8_t mask = kaonPidMask(track1); + if (grpKaon.usePID && mask == 0) { + continue; + } + histos.fill(HIST("hTrkSelInfo"), 3.5); + auto track1ID = track1.globalIndex(); + + for (const auto& track2 : negThisColl) { + histos.fill(HIST("hTrkSelInfo"), 4.5); + if (!selectionTrack(track2)) { + continue; + } + histos.fill(HIST("hTrkSelInfo"), 5.5); + + if (grpKaon.itsPIDSelection && !(itsResponse.nSigmaITS(track2) > grpKaon.lowITSPIDNsigma && itsResponse.nSigmaITS(track2) < grpKaon.highITSPIDNsigma)) { + continue; + } + histos.fill(HIST("hTrkSelInfo"), 6.5); + const uint8_t mask2 = kaonPidMask(track2); + if (grpKaon.usePID && mask2 == 0) { + continue; + } + histos.fill(HIST("hTrkSelInfo"), 7.5); + + auto track2ID = track2.globalIndex(); + + if (track2ID == track1ID) { + continue; + } + + if (!selectionPair(track1, track2)) { + continue; + } + + KaonPlus = ROOT::Math::PxPyPzMVector(track1.px(), track1.py(), track1.pz(), massKa); + KaonMinus = ROOT::Math::PxPyPzMVector(track2.px(), track2.py(), track2.pz(), massKa); + PhiMesonMother = KaonPlus + KaonMinus; + if (PhiMesonMother.M() > cfgPhiMassMin && PhiMesonMother.M() < cfgPhiMassMax) { + numberPhi = numberPhi + 1; + + histos.fill(HIST("hPhiMass"), PhiMesonMother.M()); + ROOT::Math::PtEtaPhiMVector temp1(track1.pt(), track1.eta(), track1.phi(), massKa); + ROOT::Math::PtEtaPhiMVector temp2(track2.pt(), track2.eta(), track2.phi(), massKa); + ROOT::Math::PtEtaPhiMVector temp3(PhiMesonMother.pt(), PhiMesonMother.eta(), PhiMesonMother.phi(), PhiMesonMother.M()); + + phiresonanced1.push_back(temp1); + phiresonanced2.push_back(temp2); + phiresonance.push_back(temp3); + Phid1Index.push_back(track1.globalIndex()); + Phid2Index.push_back(track2.globalIndex()); + uint16_t pairPidMask = (static_cast(mask2) << 8) | mask; + PhiPairPidMask.push_back(pairPidMask); + } + } + } + } + + if (numberPhi > 0) { + kaonkaonEvent(centrality, vz, qxZDCA, qxZDCC, qyZDCA, qyZDCC); + auto indexEvent = kaonkaonEvent.lastIndex(); + //// Fill track table for Phi////////////////// + for (auto if1 = phiresonance.begin(); if1 != phiresonance.end(); ++if1) { + auto i5 = std::distance(phiresonance.begin(), if1); + PhiVectorDummy = phiresonance.at(i5); + Phid1dummy = phiresonanced1.at(i5); + Phid2dummy = phiresonanced2.at(i5); + kaonTrack(indexEvent, Phid1dummy.Px(), Phid1dummy.Py(), Phid1dummy.Pz(), Phid2dummy.Px(), Phid2dummy.Py(), Phid2dummy.Pz(), + PhiVectorDummy.M(), Phid1Index.at(i5), Phid2Index.at(i5), PhiPairPidMask.at(i5)); + } + } + } + PROCESS_SWITCH(phiflow, processData, "Process data", true); +}; +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{adaptAnalysisTask(cfgc)}; +} From 33e59bd1b915429dd637618ac183c276338d7417 Mon Sep 17 00:00:00 2001 From: Prottay Das Date: Fri, 12 Jun 2026 17:26:01 +0200 Subject: [PATCH 2/3] corrected ML error --- PWGLF/DataModel/LFPhiFlowTables.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/PWGLF/DataModel/LFPhiFlowTables.h b/PWGLF/DataModel/LFPhiFlowTables.h index fe3f27bd642..1570df88335 100644 --- a/PWGLF/DataModel/LFPhiFlowTables.h +++ b/PWGLF/DataModel/LFPhiFlowTables.h @@ -14,8 +14,8 @@ /// /// \author Prottay Das -#ifndef PWGLF_DATAMODEL_LFPHIFLOW_H_ -#define PWGLF_DATAMODEL_LFPHIFLOW_H_ +#ifndef PWGLF_DATAMODEL_LFPHIFLOWTABLES_H_ +#define PWGLF_DATAMODEL_LFPHIFLOWTABLES_H_ #include #include @@ -75,4 +75,4 @@ DECLARE_SOA_TABLE(KaonTracks, "AOD", "KAONTRACK", using KaonTrack = KaonTracks::iterator; } // namespace o2::aod -#endif // PWGLF_DATAMODEL_LFPHIFLOW_H_ +#endif // PWGLF_DATAMODEL_LFPHIFLOWTABLES_H_ From 872e5798c521a1ab514d79f74462f1f28dd27e70 Mon Sep 17 00:00:00 2001 From: Prottay Das Date: Fri, 12 Jun 2026 17:28:48 +0200 Subject: [PATCH 3/3] removed unused par --- PWGLF/TableProducer/Resonances/phiflow.cxx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/TableProducer/Resonances/phiflow.cxx b/PWGLF/TableProducer/Resonances/phiflow.cxx index 04c157a1272..57184677c51 100644 --- a/PWGLF/TableProducer/Resonances/phiflow.cxx +++ b/PWGLF/TableProducer/Resonances/phiflow.cxx @@ -262,7 +262,7 @@ struct phiflow { ROOT::Math::PxPyPzMVector KaonPlus, KaonMinus, PhiMesonMother, PhiVectorDummy, Phid1dummy, Phid2dummy; double massKa = o2::constants::physics::MassKPlus; - void processData(EventCandidates::iterator const& collision, AllTrackCandidates const& tracks) + void processData(EventCandidates::iterator const& collision, AllTrackCandidates const& /*tracks*/) { o2::aod::ITSResponse itsResponse; int numberPhi = 0;