From 39a333d6c3008bcf551e4a52a4d815e418bb38f3 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 19:11:54 +0800 Subject: [PATCH 01/10] Add files via upload --- PWGLF/DataModel/DrvCollisions.h | 81 +++++++++++++++++++++++++++ PWGLF/DataModel/LFStrangenessTables.h | 54 ++++++++++++++++++ 2 files changed, 135 insertions(+) create mode 100644 PWGLF/DataModel/DrvCollisions.h diff --git a/PWGLF/DataModel/DrvCollisions.h b/PWGLF/DataModel/DrvCollisions.h new file mode 100644 index 00000000000..870a7273460 --- /dev/null +++ b/PWGLF/DataModel/DrvCollisions.h @@ -0,0 +1,81 @@ + +#include "Framework/ASoA.h" +#include "Framework/AnalysisDataModel.h" + +namespace o2::aod +{ +namespace drvcollision +{ +DECLARE_SOA_COLUMN(Timestamp, timestamp, uint64_t); +DECLARE_SOA_COLUMN(RunNumber, runNumber, int); //! Run number +DECLARE_SOA_COLUMN(GlobalBC, globalBC, uint64_t); //! Bunch crossing number (globally unique in this run) + +DECLARE_SOA_INDEX_COLUMN(BC, bc); //! Most probably BC to where this collision has occured +DECLARE_SOA_COLUMN(PosX, posX, float); //! X Vertex position in cm +DECLARE_SOA_COLUMN(PosY, posY, float); //! Y Vertex position in cm +DECLARE_SOA_COLUMN(PosZ, posZ, float); //! Z Vertex position in cm +DECLARE_SOA_COLUMN(CovXX, covXX, float); //! Vertex covariance matrix +DECLARE_SOA_COLUMN(CovXY, covXY, float); //! Vertex covariance matrix +DECLARE_SOA_COLUMN(CovXZ, covXZ, float); //! Vertex covariance matrix +DECLARE_SOA_COLUMN(CovYY, covYY, float); //! Vertex covariance matrix +DECLARE_SOA_COLUMN(CovYZ, covYZ, float); //! Vertex covariance matrix +DECLARE_SOA_COLUMN(CovZZ, covZZ, float); //! Vertex covariance matrix +DECLARE_SOA_COLUMN(CentFT0C, centFT0C, float); +DECLARE_SOA_COLUMN(CentFT0M, centFT0M, float); +DECLARE_SOA_COLUMN(MultNTracksPVeta1, multNTracksPVeta1, int); +DECLARE_SOA_COLUMN(IsInelGt0, isInelGt0, bool); +DECLARE_SOA_COLUMN(IsInelGt1, isInelGt1, bool); +DECLARE_SOA_COLUMN(Flags, flags, uint16_t); //! Run 2: see CollisionFlagsRun2 | Run 3: see Vertex::Flags +DECLARE_SOA_COLUMN(Chi2, chi2, float); //! Chi2 of vertex fit +DECLARE_SOA_COLUMN(NumContrib, numContrib, uint16_t); //! Number of tracks used for the vertex +DECLARE_SOA_COLUMN(CollisionTime, collisionTime, float); //! Collision time in ns relative to BC stored in bc() +DECLARE_SOA_COLUMN(CollisionTimeRes, collisionTimeRes, float); //! Resolution of collision time + +DECLARE_SOA_COLUMN(Pt, pt, float); +DECLARE_SOA_COLUMN(Eta, eta, float); +DECLARE_SOA_COLUMN(Phi, phi, float); +DECLARE_SOA_COLUMN(Sign, sign, int8_t); +DECLARE_SOA_COLUMN(Signed1Pt, signed1Pt, float); +DECLARE_SOA_COLUMN(Px, px, float); +DECLARE_SOA_COLUMN(Py, py, float); +DECLARE_SOA_COLUMN(Pz, pz, float); +DECLARE_SOA_COLUMN(TPCNClsCrossedRows, tpcNClsCrossedRows, int16_t); +DECLARE_SOA_COLUMN(HasITS, hasITS, bool); +DECLARE_SOA_COLUMN(TPCNClsShared, tpcNClsShared, int16_t); +DECLARE_SOA_COLUMN(ITSClusterMap, itsClusterMap, uint32_t); +DECLARE_SOA_COLUMN(DcaXY, dcaXY, float); +DECLARE_SOA_COLUMN(CollisionId, collisionId, int32_t); +DECLARE_SOA_COLUMN(TPCNSigmaPi, tpcNSigmaPi, float); +DECLARE_SOA_COLUMN(TPCNSigmaPr, tpcNSigmaPr, float); +} // namespace drvcollision +DECLARE_SOA_TABLE(DrvTracks, "AOD", "DRVTRACKS", + o2::soa::Index<>, + drvcollision::CollisionId, + drvcollision::Pt, + drvcollision::Eta, + drvcollision::Phi, + drvcollision::Sign, + drvcollision::Signed1Pt, + drvcollision::Px, + drvcollision::Py, + drvcollision::Pz, + drvcollision::TPCNClsCrossedRows, + drvcollision::HasITS, + drvcollision::TPCNClsShared, + drvcollision::ITSClusterMap, + drvcollision::DcaXY, + drvcollision::TPCNSigmaPi, + drvcollision::TPCNSigmaPr); + +DECLARE_SOA_TABLE(DrvCollisions, "AOD", "DRVCOLLISION", //! Time and vertex information of collision + o2::soa::Index<>, drvcollision::BCId, + drvcollision::PosX, drvcollision::PosY, drvcollision::PosZ, drvcollision::MultNTracksPVeta1, + drvcollision::CovXX, drvcollision::CovXY, drvcollision::CovXZ, drvcollision::CovYY, drvcollision::CovYZ, drvcollision::CovZZ, + drvcollision::CentFT0C, drvcollision::CentFT0M, drvcollision::IsInelGt0, drvcollision::IsInelGt1, drvcollision::Flags, drvcollision::Chi2, drvcollision::NumContrib, + drvcollision::CollisionTime, drvcollision::CollisionTimeRes); + +DECLARE_SOA_TABLE(BCandTime, "AOD", "BCANDTIME", + o2::soa::Index<>, + drvcollision::Timestamp, + drvcollision::RunNumber, drvcollision::GlobalBC); +} // namespace o2::aod diff --git a/PWGLF/DataModel/LFStrangenessTables.h b/PWGLF/DataModel/LFStrangenessTables.h index bc7fd7d3aaa..9f553e13251 100644 --- a/PWGLF/DataModel/LFStrangenessTables.h +++ b/PWGLF/DataModel/LFStrangenessTables.h @@ -912,6 +912,60 @@ DECLARE_SOA_TABLE_STAGED(V0CoresBase, "V0CORE", //! core information about decay v0data::IsStandardV0, v0data::IsPhotonTPConly); +DECLARE_SOA_TABLE_STAGED(V0CoresBaseWithDua, "V0COREWITHDAU", //! core information about decay, viable with AO2Ds or derived + o2::soa::Index<>, + v0data::X, v0data::Y, v0data::Z, + v0data::PxPos, v0data::PyPos, v0data::PzPos, + v0data::PxNeg, v0data::PyNeg, v0data::PzNeg, + v0data::DCAV0Daughters, v0data::DCAPosToPV, v0data::DCANegToPV, + v0data::V0CosPA, v0data::DCAV0ToPV, v0data::V0Type, + v0data::PosTrackId, v0data::NegTrackId, v0data::CollisionId, + + // Dynamic columns + v0data::Px, + v0data::Py, + v0data::Pz, + v0data::Pt, + v0data::P, + v0data::Phi, + v0data::Eta, + v0data::PtHypertriton, + v0data::PtAntiHypertriton, + v0data::V0Radius, + v0data::DistOverTotMom, + v0data::Alpha, + v0data::QtArm, + v0data::PsiPair, + v0data::PFracPos, + v0data::PFracNeg, // 24 + + // Invariant masses + v0data::MLambda, + v0data::MAntiLambda, + v0data::MK0Short, + v0data::MLambda_unchecked, + v0data::MAntiLambda_unchecked, + v0data::MK0Short_unchecked, + v0data::MGamma, + v0data::MHypertriton, + v0data::MAntiHypertriton, + v0data::M, + + // Longitudinal + v0data::YK0Short, + v0data::YLambda, + v0data::YHypertriton, + v0data::YAntiHypertriton, + v0data::Rapidity, + v0data::NegativePt, + v0data::PositivePt, + v0data::NegativeEta, + v0data::NegativePhi, + v0data::PositiveEta, + v0data::PositivePhi, + v0data::IsStandardV0, + v0data::IsPhotonTPConly); + // extended table with expression columns that can be used as arguments of dynamic columns // DECLARE_SOA_EXTENDED_TABLE_USER(V0Cores, V0CoresBase, "V0COREEXT", //! // v0data::Px, v0data::Py, v0data::Pz, v0data::Pt, v0data::P, v0data::Phi, v0data::Eta); // the table name has here to be the one with EXT which is not nice and under study From c2a1db17cf7e00fbde4ca2bf2a724a32bd60352d Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 19:12:46 +0800 Subject: [PATCH 02/10] Add files via upload --- .../TableProducer/Strangeness/CMakeLists.txt | 5 + .../Strangeness/hStrangeDerivedData.cxx | 472 ++++++++++++++++++ 2 files changed, 477 insertions(+) create mode 100644 PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx diff --git a/PWGLF/TableProducer/Strangeness/CMakeLists.txt b/PWGLF/TableProducer/Strangeness/CMakeLists.txt index 758ffe04948..673c3062e42 100644 --- a/PWGLF/TableProducer/Strangeness/CMakeLists.txt +++ b/PWGLF/TableProducer/Strangeness/CMakeLists.txt @@ -50,6 +50,11 @@ o2physics_add_dpl_workflow(hstrangecorrelationfilter SOURCES hStrangeCorrelationFilter.cxx PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore O2Physics::EventFilteringUtils COMPONENT_NAME Analysis) + +o2physics_add_dpl_workflow(hstrangederiveddata + SOURCES hStrangeDerivedData.cxx + PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore O2Physics::EventFilteringUtils + COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(double-casc-tree-creator SOURCES doubleCascTreeCreator.cxx diff --git a/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx b/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx new file mode 100644 index 00000000000..c269bcaa964 --- /dev/null +++ b/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx @@ -0,0 +1,472 @@ +// 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. +/// + +#include "PWGLF/DataModel/DrvCollisions.h" +#include "PWGLF/DataModel/LFHStrangeCorrelationTables.h" +#include "PWGLF/DataModel/LFStrangenessTables.h" + +#include "Common/Core/Zorro.h" +#include "Common/Core/ZorroSummary.h" +#include "Common/DataModel/Centrality.h" +#include "Common/DataModel/EventSelection.h" +#include "Common/DataModel/Multiplicity.h" +#include "Common/DataModel/PIDResponseTOF.h" +#include "Common/DataModel/PIDResponseTPC.h" +#include "Common/DataModel/TrackSelectionTables.h" + +#include "Framework/ASoAHelpers.h" +#include "Framework/AnalysisTask.h" +#include "Framework/runDataProcessing.h" + +#include "TF1.h" +#include + +#include + +using namespace o2; +using namespace o2::constants::math; +using namespace o2::framework; +using namespace o2::framework::expressions; + +#define BIT_SET(var, nbit) ((var) |= (1 << (nbit))) +#define BIT_CHECK(var, nbit) ((var) & (1 << (nbit))) + +struct HStrangeDerivedData { + + // master analysis switches + Configurable doPPAnalysis{"doPPAnalysis", true, "if in pp, set to true"}; + Configurable useParameterization{"useParameterization", true, "ture for parameterization method, false for hist method"}; + // Operational + Configurable fillTableOnlyWithCompatible{"fillTableOnlyWithCompatible", true, "pre-apply dE/dx, broad mass window in table filling"}; + Configurable strangedEdxNSigmaLoose{"strangedEdxNSigmaLoose", 5, "Nsigmas for strange decay daughters"}; + Configurable strangedEdxNSigma{"strangedEdxNSigma", 4, "Nsigmas for strange decay daughters"}; + Configurable strangedEdxNSigmaTight{"strangedEdxNSigmaTight", 3, "Nsigmas for strange decay daughters"}; + Configurable nSigmaNearXiMassCenter{"nSigmaNearXiMassCenter", 0, "for Oemga analysis only, to check if candidate mass is around Xi"}; + + // used for event selections in Pb-Pb + Configurable cfgCutOccupancyHigh{"cfgCutOccupancyHigh", 3000, "High cut on TPC occupancy"}; + Configurable cfgCutOccupancyLow{"cfgCutOccupancyLow", 0, "Low cut on TPC occupancy"}; + + struct : ConfigurableGroup { + // event filtering + Configurable zVertexCut{"zVertexCut", 10, "Cut on PV position"}; + Configurable selectINELgtZERO{"selectINELgtZERO", true, "select INEL>0 events"}; + Configurable requireAllGoodITSLayers{"requireAllGoodITSLayers", false, " require that in the event all ITS are good"}; + } eventSelections; + + struct : ConfigurableGroup { + // Trigger particle selections in phase space + Configurable triggerEtaMin{"triggerEtaMin", -0.8, "triggeretamin"}; + Configurable triggerEtaMax{"triggerEtaMax", 0.8, "triggeretamax"}; + Configurable triggerPtCutMin{"triggerPtCutMin", 8, "triggerptmin"}; + Configurable triggerPtCutMax{"triggerPtCutMax", 20, "triggerptmax"}; + + // Track quality + Configurable minTPCNCrossedRows{"minTPCNCrossedRows", 70, "Minimum TPC crossed rows"}; + Configurable triggerRequireITS{"triggerRequireITS", true, "require ITS signal in trigger tracks"}; + Configurable assocRequireITS{"assocRequireITS", true, "require ITS signal in assoc tracks"}; + Configurable triggerMaxTPCSharedClusters{"triggerMaxTPCSharedClusters", 200, "maximum number of shared TPC clusters (inclusive)"}; + Configurable triggerRequireL0{"triggerRequireL0", false, "require ITS L0 cluster for trigger"}; + + // Associated particle selections in phase space + Configurable assocEtaMin{"assocEtaMin", -0.8, "triggeretamin"}; + Configurable assocEtaMax{"assocEtaMax", 0.8, "triggeretamax"}; + Configurable assocPtCutMin{"assocPtCutMin", 0.2, "assocptmin"}; + Configurable assocPtCutMax{"assocPtCutMax", 10, "assocptmax"}; + + // Associated pion identification + Configurable pionMinBayesProb{"pionMinBayesProb", 0.95, "minimal Bayesian probability for pion ID"}; + Configurable assocPionNSigmaTPCFOF{"assocPionNSigmaTPCFOF", 3, "minimal n sigma in TOF and TPC for Pion ID"}; + Configurable rejectSigma{"rejectSigma", 1, "n sigma for rejecting pion candidates"}; + + // V0 selections + Configurable v0Cospa{"v0Cospa", 0.97, "V0 CosPA"}; // double -> N.B. dcos(x)/dx = 0 at x=0) + Configurable dcaV0dau{"dcaV0dau", 1.0, "DCA V0 Daughters"}; + Configurable dcaNegtopv{"dcaNegtopv", 0.06, "DCA Neg To PV"}; + Configurable dcaPostopv{"dcaPostopv", 0.06, "DCA Pos To PV"}; + Configurable v0RadiusMin{"v0RadiusMin", 0.5, "v0radius"}; + Configurable v0RadiusMax{"v0RadiusMax", 200, "v0radius"}; + // more V0 selections in PbPb + Configurable lifetimecutK0S{"lifetimecutK0S", 20, "lifetimecutK0S"}; + Configurable lifetimecutLambda{"lifetimecutLambda", 30, "lifetimecutLambda"}; + Configurable dcanegtopvK0S{"dcanegtopvK0S", 0.1, "DCA Neg To PV"}; + Configurable dcapostopvK0S{"dcapostopvK0S", 0.1, "DCA Pos To PV"}; + Configurable dcanegtopvLambda{"dcanegtopvLambda", 0.05, "DCA Neg To PV"}; + Configurable dcapostopvLambda{"dcapostopvLambda", 0.2, "DCA Pos To PV"}; + Configurable dcanegtopvAntiLambda{"dcanegtopvAntiLambda", 0.2, "DCA Neg To PV"}; + Configurable dcapostopvAntiLambda{"dcapostopvAntiLambda", 0.05, "DCA Pos To PV"}; + // original equation: lArmPt*2>TMath::Abs(lArmAlpha) only for K0S + Configurable armPodCut{"armPodCut", 5.0f, "pT * (cut) > |alpha|, AP cut. Negative: no cut"}; + + // specific selections + Configurable lambdaCospa{"lambdaCospa", 0.995, "CosPA for lambda"}; // allows for tighter selection for Lambda + + // primary particle DCAxy selections + // formula: |DCAxy| < 0.004f + (0.013f / pt) + Configurable dcaXYconstant{"dcaXYconstant", 0.004, "[0] in |DCAxy| < [0]+[1]/pT"}; + Configurable dcaXYpTdep{"dcaXYpTdep", 0.013, "[1] in |DCAxy| < [0]+[1]/pT"}; + + // cascade selections + Configurable cascCospa{"cascCospa", 0.95, "cascCospa"}; + Configurable cascRadius{"cascRadius", 0.5, "cascRadius"}; + Configurable dcaCascdau{"dcaCascdau", 1.0, "dcaCascdau"}; + Configurable dcaBachtopv{"dcaBachtopv", 0.1, "dcaBachtopv"}; + Configurable cascV0masswindow{"cascV0masswindow", 0.01, "cascV0masswindow"}; + Configurable cascMindcav0topv{"cascMindcav0topv", 0.01, "cascMindcav0topv"}; + } systCuts; + struct : ConfigurableGroup { + // cascade selections in PbPb + Configurable cascDcacascdau{"cascDcacascdau", 1.0, "cascDcacascdau"}; + Configurable cascDcabachtopv{"cascDcabachtopv", 0.1, "cascDcabachtopv"}; + Configurable bachBaryonCosPA{"bachBaryonCosPA", 0.9999, "Bachelor baryon CosPA"}; + Configurable bachBaryonDCAxyToPV{"bachBaryonDCAxyToPV", 0.08, "DCA bachelor baryon to PV"}; + Configurable dcaBaryonToPV{"dcaBaryonToPV", 0.05, "DCA of baryon doughter track To PV"}; + Configurable dcaMesonToPV{"dcaMesonToPV", 0.1, "DCA of meson doughter track To PV"}; + Configurable dcaBachToPV{"dcaBachToPV", 0.07, "DCA Bach To PV"}; + Configurable cascdcaV0dau{"cascdcaV0dau", 0.5, "DCA V0 Daughters"}; + Configurable dcaCacsDauPar0{"dcaCacsDauPar0", 0.8, " par for pt dep DCA cascade daughter cut, p_T < 1 GeV/c"}; + Configurable dcaCacsDauPar1{"dcaCacsDauPar1", 0.5, " par for pt dep DCA cascade daughter cut, 1< p_T < 4 GeV/c"}; + Configurable dcaCacsDauPar2{"dcaCacsDauPar2", 0.2, " par for pt dep DCA cascade daughter cut, p_T > 4 GeV/c"}; + Configurable cascdcaV0ToPV{"cascdcaV0ToPV", 0.06, "DCA V0 To PV"}; + Configurable cascv0cospa{"cascv0cospa", 0.98, "V0 CosPA"}; + Configurable cascv0RadiusMin{"cascv0RadiusMin", 2.5, "v0radius"}; + Configurable proplifetime{"proplifetime", 3, "ctau/"}; + Configurable lambdaMassWin{"lambdaMassWin", 0.005, "V0 Mass window limit"}; + Configurable rejcomp{"rejcomp", 0.008, "Competing Cascade rejection"}; + Configurable rapCut{"rapCut", 0.8, "Rapidity acceptance"}; + } MorePbPbsystCuts; + // must include windows for background and peak + Configurable maxMassNSigma{"maxMassNSigma", 12.0f, "max mass region to be considered for further analysis"}; + + // For extracting strangeness mass QA plots + struct : ConfigurableGroup { + ConfigurableAxis axisPtQA{"axisPtQA", {VARIABLE_WIDTH, 0.0f, 0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f, 1.3f, 1.4f, 1.5f, 1.6f, 1.7f, 1.8f, 1.9f, 2.0f, 2.2f, 2.4f, 2.6f, 2.8f, 3.0f, 3.2f, 3.4f, 3.6f, 3.8f, 4.0f, 4.4f, 4.8f, 5.2f, 5.6f, 6.0f, 6.5f, 7.0f, 7.5f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 17.0f, 19.0f, 21.0f, 23.0f, 25.0f, 30.0f, 35.0f, 40.0f, 50.0f}, "pt axis for QA histograms"}; + ConfigurableAxis axisK0ShortMass{"axisK0ShortMass", {200, 0.400f, 0.600f}, "Inv. Mass (GeV/c^{2})"}; + ConfigurableAxis axisLambdaMass{"axisLambdaMass", {200, 1.01f, 1.21f}, "Inv. Mass (GeV/c^{2})"}; + ConfigurableAxis axisXiMass{"axisXiMass", {200, 1.22f, 1.42f}, "Inv. Mass (GeV/c^{2})"}; + ConfigurableAxis axisOmegaMass{"axisOmegaMass", {200, 1.57f, 1.77f}, "Inv. Mass (GeV/c^{2})"}; + ConfigurableAxis axisMult{"axisMult", {VARIABLE_WIDTH, 0.0f, 0.01f, 1.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 70.0f, 100.0f}, "Centrality percentile bins"}; + } axesConfigurations; + + // QA + Configurable doTrueSelectionInMass{"doTrueSelectionInMass", false, "Fill mass histograms only with true primary Particles for MC"}; + // Do declarative selections for DCAs, if possible + Filter preFilterTracks = nabs(aod::track::dcaXY) < systCuts.dcaXYconstant + systCuts.dcaXYpTdep * nabs(aod::track::signed1Pt); + Filter preFilterV0 = nabs(aod::v0data::dcapostopv) > systCuts.dcaPostopv&& + nabs(aod::v0data::dcanegtopv) > systCuts.dcaNegtopv&& aod::v0data::dcaV0daughters < systCuts.dcaV0dau; + Filter preFilterCascade = + nabs(aod::cascdata::dcapostopv) > systCuts.dcaPostopv&& nabs(aod::cascdata::dcanegtopv) > systCuts.dcaNegtopv&& nabs(aod::cascdata::dcabachtopv) > systCuts.dcaBachtopv&& aod::cascdata::dcaV0daughters < systCuts.dcaV0dau&& aod::cascdata::dcacascdaughters < systCuts.dcaCascdau; + + // using V0LinkedTagged = soa::Join; + // using CascadesLinkedTagged = soa::Join; + using FullTracks = soa::Join; + using FullTracksMC = soa::Join; + using DauTracks = soa::Join; + using DauTracksMC = soa::Join; + // using IDTracks= soa::Join; // prepared for Bayesian PID + using IDTracks = soa::Join; + using IDTracksMC = soa::Join; + using V0DatasWithoutTrackX = soa::Join; + using V0DatasWithoutTrackXMC = soa::Join; + using CascDatasMC = soa::Join; + + Produces triggerTrack; + Produces triggerTrackExtra; + Produces assocV0; + Produces assocCascades; + Produces assocHadrons; + Produces assocPID; + + Produces v0cores; + Produces drvtracks; + Produces bcAndTime; + Produces newCollisions; + + struct : ConfigurableGroup { + // invariant mass parametrizations + Configurable> massParsK0Mean{"massParsK0Mean", {0.495967, 0.000095, 0.001120, 0.800000}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + Configurable> massParsK0Width{"massParsK0Width", {0.002324, 0.000600, 0.005076, 1.644687}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + + Configurable> massParsLambdaMean{"massParsLambdaMean", {1.115554, 0.000002, -0.000311, 1.303969}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + Configurable> massParsLambdaWidth{"massParsLambdaWidth", {0.001066, 0.000168, 0.001893, 1.407199}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + + Configurable> massParsCascadeMean{"massParsCascadeMean", {1.322150, -0.000087, -0.000761, 0.316391}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + Configurable> massParsCascadeWidth{"massParsCascadeWidth", {0.001269, 0.000249, 0.002790, 1.128544}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + + Configurable> massParsOmegaMean{"massParsOmegaMean", {1.671908, -0.000000, 0.001027, 2.263832}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + Configurable> massParsOmegaWidth{"massParsOmegaWidth", {0.001223, 0.000300, 0.040718, 2.826750}, "pars in [0]+[1]*x+[2]*std::exp(-[3]*x)"}; + } parameters; + TF1* fK0Mean = new TF1("fK0Mean", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + TF1* fK0Width = new TF1("fK0Width", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + TF1* fLambdaMean = new TF1("fLambdaMean", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + TF1* fLambdaWidth = new TF1("fLambdaWidth", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + TF1* fXiMean = new TF1("fXiMean", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + TF1* fXiWidth = new TF1("fXiWidth", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + TF1* fOmegaMean = new TF1("fomegaMean", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + TF1* fOmegaWidth = new TF1("fomegaWidth", "[0]+[1]*x+[2]*std::exp(-[3]*x)"); + void init(InitContext const&) + { + if (useParameterization) { + fK0Mean->SetParameters(parameters.massParsK0Mean->at(0), parameters.massParsK0Mean->at(1), parameters.massParsK0Mean->at(2), parameters.massParsK0Mean->at(3)); + fK0Width->SetParameters(parameters.massParsK0Width->at(0), parameters.massParsK0Width->at(1), parameters.massParsK0Width->at(2), parameters.massParsK0Width->at(3)); + fLambdaMean->SetParameters(parameters.massParsLambdaMean->at(0), parameters.massParsLambdaMean->at(1), parameters.massParsLambdaMean->at(2), parameters.massParsLambdaMean->at(3)); + fLambdaWidth->SetParameters(parameters.massParsLambdaWidth->at(0), parameters.massParsLambdaWidth->at(1), parameters.massParsLambdaWidth->at(2), parameters.massParsLambdaWidth->at(3)); + fXiMean->SetParameters(parameters.massParsCascadeMean->at(0), parameters.massParsCascadeMean->at(1), parameters.massParsCascadeMean->at(2), parameters.massParsCascadeMean->at(3)); + fXiWidth->SetParameters(parameters.massParsCascadeWidth->at(0), parameters.massParsCascadeWidth->at(1), parameters.massParsCascadeWidth->at(2), parameters.massParsCascadeWidth->at(3)); + fOmegaMean->SetParameters(parameters.massParsOmegaMean->at(0), parameters.massParsOmegaMean->at(1), parameters.massParsOmegaMean->at(2), parameters.massParsOmegaMean->at(3)); + fOmegaWidth->SetParameters(parameters.massParsOmegaWidth->at(0), parameters.massParsOmegaWidth->at(1), parameters.massParsOmegaWidth->at(2), parameters.massParsOmegaWidth->at(3)); + } + } + template + bool isValidTrigger(TTrack track) + { + if (track.eta() > systCuts.triggerEtaMax || track.eta() < systCuts.triggerEtaMin) { + return false; + } + if (track.pt() > systCuts.triggerPtCutMax || track.pt() < systCuts.triggerPtCutMin) { + return false; + } + if (track.tpcNClsCrossedRows() < systCuts.minTPCNCrossedRows) { + return false; // crossed rows + } + if (!track.hasITS() && systCuts.triggerRequireITS) { + return false; // skip, doesn't have ITS signal (skips lots of TPC-only!) + } + if (track.tpcNClsShared() > systCuts.triggerMaxTPCSharedClusters) { + return false; // skip, has shared clusters + } + if (!(TESTBIT(track.itsClusterMap(), 0)) && systCuts.triggerRequireL0) { + return false; // skip, doesn't have cluster in ITS L0 + } + // systematic variations: trigger DCAxy + if (std::abs(track.dcaXY()) > systCuts.dcaXYconstant + systCuts.dcaXYpTdep * std::abs(track.signed1Pt())) { + return false; + } + return true; + } + template + bool hasValidTrigger(TTracks tracks) + { + for (auto const& track : tracks) { + if (!isValidTrigger(track)) + continue; + return true; + } + return false; + } + template + bool isCollisionSelectedPbPb(TCollision collision) + { + if (!collision.selection_bit(aod::evsel::kIsTriggerTVX)) /* FT0 vertex (acceptable FT0C-FT0A time difference) collisions */ + return false; + if (!collision.selection_bit(o2::aod::evsel::kIsGoodITSLayersAll)) // cut time intervals with dead ITS staves + return false; + if (!collision.selection_bit(o2::aod::evsel::kIsGoodZvtxFT0vsPV)) // removes collisions with large differences between z of PV by tracks and z of PV from FT0 A-C time difference + return false; + auto occupancy = collision.trackOccupancyInTimeRange(); + if (occupancy < cfgCutOccupancyLow || occupancy > cfgCutOccupancyHigh) /* Below min occupancy and Above max occupancy*/ + return false; + if (!collision.selection_bit(o2::aod::evsel::kNoTimeFrameBorder)) // reject collisions close to Time Frame borders + return false; + if (!collision.selection_bit(o2::aod::evsel::kNoITSROFrameBorder)) // reject events affected by the ITS ROF border + return false; + if (!collision.selection_bit(o2::aod::evsel::kNoSameBunchPileup)) // rejects collisions which are associated with the same "found-by-T0" bunch crossing + return false; + return true; + } + template + bool isValidV0(TCollision collision, TV0 const& v0) + { + if (v0.v0radius() < systCuts.v0RadiusMin || v0.v0radius() > systCuts.v0RadiusMax || v0.eta() > systCuts.assocEtaMax || v0.eta() < systCuts.assocEtaMin || v0.v0cosPA() < systCuts.v0Cospa) { + return false; + } + if (v0.pt() > systCuts.assocPtCutMax || v0.pt() < systCuts.assocPtCutMin) { + return false; + } + // check dE/dx compatibility + int compatibleK0Short = 0; + int compatibleLambda = 0; + int compatibleAntiLambda = 0; + + auto posdau = v0.template posTrack_as(); + auto negdau = v0.template negTrack_as(); + + if (negdau.tpcNClsCrossedRows() < systCuts.minTPCNCrossedRows) + return false; + if (posdau.tpcNClsCrossedRows() < systCuts.minTPCNCrossedRows) + return false; + + if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose) { + if (doPPAnalysis || (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < systCuts.lifetimecutK0S && + std::abs(v0.dcapostopv()) > systCuts.dcapostopvK0S && std::abs(v0.dcanegtopv()) > systCuts.dcanegtopvK0S && + v0.qtarm() * systCuts.armPodCut > std::abs(v0.alpha()))) { + BIT_SET(compatibleK0Short, 0); + } + } + + if (std::abs(posdau.tpcNSigmaPr()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose) { + if (v0.v0cosPA() > systCuts.lambdaCospa) { + if (doPPAnalysis || (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < systCuts.lifetimecutLambda && + std::abs(v0.dcapostopv()) > systCuts.dcapostopvLambda && std::abs(v0.dcanegtopv()) > systCuts.dcanegtopvLambda)) { + BIT_SET(compatibleLambda, 0); + } + } + } + + if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPr()) < strangedEdxNSigmaLoose) { + if (v0.v0cosPA() > systCuts.lambdaCospa) { + if (doPPAnalysis || (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < systCuts.lifetimecutLambda && + std::abs(v0.dcapostopv()) > systCuts.dcapostopvAntiLambda && std::abs(v0.dcanegtopv()) > systCuts.dcanegtopvAntiLambda)) { + BIT_SET(compatibleAntiLambda, 0); + } + } + } + float massNSigmaK0Short = -20.0f; + float massNSigmaLambda = -20.0f; + float massNSigmaAntiLambda = -20.0f; + + massNSigmaK0Short = (v0.mK0Short() - fK0Mean->Eval(v0.pt())) / (fK0Width->Eval(v0.pt()) + 1e-6); + massNSigmaLambda = (v0.mLambda() - fLambdaMean->Eval(v0.pt())) / (fLambdaWidth->Eval(v0.pt()) + 1e-6); + massNSigmaAntiLambda = (v0.mAntiLambda() - fLambdaMean->Eval(v0.pt())) / (fLambdaWidth->Eval(v0.pt()) + 1e-6); + + if ((compatibleK0Short > 0 && std::abs(massNSigmaK0Short) < maxMassNSigma) || + (compatibleLambda > 0 && std::abs(massNSigmaLambda) < maxMassNSigma) || + (compatibleAntiLambda > 0 && std::abs(massNSigmaAntiLambda) < maxMassNSigma)) + return true; + + return false; + } + template + bool hasValidV0(TCollision collision, TV0s const& V0s) + { + for (auto const& v0 : V0s) { + if (isValidV0(collision, v0)) { + return true; + } + } + return false; + } + void processProduceDerivedData(soa::Join::iterator const& collision, DauTracks const& tracks, soa::Filtered const& v0s, aod::BCsWithTimestamps const&) + { + if (!isCollisionSelectedPbPb(collision)) + return; + if (!hasValidTrigger(tracks)) + return; + if (!hasValidV0(collision, v0s)) + return; + + newCollisions(collision.bcId(), + collision.posX(), collision.posY(), collision.posZ(), + collision.covXX(), collision.covXY(), collision.covYY(), collision.covXZ(), collision.covYZ(), collision.covZZ(), + collision.centFT0C(), collision.centFT0M(), + collision.multNTracksPVeta1(), + collision.isInelGt0(), collision.isInelGt1(), + collision.flags(), + collision.chi2(), + collision.numContrib(), + collision.collisionTime(), + collision.collisionTimeRes()); + auto bc = collision.bc_as(); + bcAndTime( + bc.timestamp(), + bc.runNumber(), + bc.globalBC()); + + std::unordered_set selectedTrackIndexSet; + + for (auto const& track : tracks) { + if (!isValidTrigger(track)) + continue; + selectedTrackIndexSet.insert(track.globalIndex()); + drvtracks( + track.collisionId(), + track.pt(), + track.eta(), + track.phi(), + track.sign(), + track.signed1Pt(), + track.px(), + track.py(), + track.pz(), + track.tpcNClsCrossedRows(), + track.hasITS(), + track.tpcNClsShared(), + track.itsClusterMap(), + track.dcaXY(), + track.tpcNSigmaPi(), + track.tpcNSigmaPr()); + } + for (auto const& v0 : v0s) { + if (!isValidV0(collision, v0)) + continue; + auto posdau = v0.posTrack_as(); + auto negdau = v0.negTrack_as(); + + if (selectedTrackIndexSet.count(posdau.globalIndex()) > 0 || selectedTrackIndexSet.count(negdau.globalIndex()) > 0) { + continue; + } + + v0cores(v0.x(), v0.y(), v0.z(), + v0.pxpos(), v0.pypos(), v0.pzpos(), + v0.pxneg(), v0.pyneg(), v0.pzneg(), + v0.dcaV0daughters(), + v0.dcapostopv(), + v0.dcanegtopv(), + v0.v0cosPA(), + v0.dcav0topv(), + v0.v0Type(), + v0.posTrackId(), + v0.negTrackId(), + v0.collisionId()); + // drvtracks( + // posdau.collisionId(), + // posdau.pt(), + // posdau.eta(), + // posdau.phi(), + // posdau.sign(), + // posdau.signed1Pt(), + // posdau.px(), + // posdau.py(), + // posdau.pz(), + // posdau.tpcNClsCrossedRows(), + // posdau.hasITS(), + // posdau.tpcNClsShared(), + // posdau.itsClusterMap(), + // posdau.dcaXY(), + // posdau.tpcNSigmaPi(), + // posdau.tpcNSigmaPr()); + // drvtracks( + // negdau.collisionId(), + // negdau.pt(), + // negdau.eta(), + // negdau.phi(), + // negdau.sign(), + // negdau.signed1Pt(), + // negdau.px(), + // negdau.py(), + // negdau.pz(), + // negdau.tpcNClsCrossedRows(), + // negdau.hasITS(), + // negdau.tpcNClsShared(), + // negdau.itsClusterMap(), + // negdau.dcaXY(), + // negdau.tpcNSigmaPi(), + // negdau.tpcNSigmaPr()); + } + } + PROCESS_SWITCH(HStrangeDerivedData, processProduceDerivedData, "Produce DerivedData", true); +}; +WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) +{ + return WorkflowSpec{ + adaptAnalysisTask(cfgc)}; +} From d7cb720397bff0f88a9e6d4c560d46ec505eae68 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 19:20:20 +0800 Subject: [PATCH 03/10] Add files via upload --- PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx b/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx index c269bcaa964..90200184b00 100644 --- a/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx +++ b/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx @@ -232,7 +232,7 @@ struct HStrangeDerivedData { if (track.eta() > systCuts.triggerEtaMax || track.eta() < systCuts.triggerEtaMin) { return false; } - if (track.pt() > systCuts.triggerPtCutMax || track.pt() < systCuts.triggerPtCutMin) { + if (track.pt() > systCuts.triggerPtCutMax || track.pt() < systCuts.triggerPtCutMin) { return false; } if (track.tpcNClsCrossedRows() < systCuts.minTPCNCrossedRows) { @@ -304,7 +304,8 @@ struct HStrangeDerivedData { return false; if (posdau.tpcNClsCrossedRows() < systCuts.minTPCNCrossedRows) return false; - + if (v0.dcaV0daughters() > systCuts.dcaV0dau) + return false; if (std::abs(posdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose && std::abs(negdau.tpcNSigmaPi()) < strangedEdxNSigmaLoose) { if (doPPAnalysis || (v0.distovertotmom(collision.posX(), collision.posY(), collision.posZ()) * o2::constants::physics::MassK0Short < systCuts.lifetimecutK0S && std::abs(v0.dcapostopv()) > systCuts.dcapostopvK0S && std::abs(v0.dcanegtopv()) > systCuts.dcanegtopvK0S && From 88f745888beb0a09e6f8fb80a0ca98ef3e6bbac8 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 19:28:24 +0800 Subject: [PATCH 04/10] Add files via upload --- PWGLF/TableProducer/Strangeness/CMakeLists.txt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/PWGLF/TableProducer/Strangeness/CMakeLists.txt b/PWGLF/TableProducer/Strangeness/CMakeLists.txt index 673c3062e42..8593403b0bb 100644 --- a/PWGLF/TableProducer/Strangeness/CMakeLists.txt +++ b/PWGLF/TableProducer/Strangeness/CMakeLists.txt @@ -50,11 +50,6 @@ o2physics_add_dpl_workflow(hstrangecorrelationfilter SOURCES hStrangeCorrelationFilter.cxx PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore O2Physics::EventFilteringUtils COMPONENT_NAME Analysis) - -o2physics_add_dpl_workflow(hstrangederiveddata - SOURCES hStrangeDerivedData.cxx - PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore O2Physics::EventFilteringUtils - COMPONENT_NAME Analysis) o2physics_add_dpl_workflow(double-casc-tree-creator SOURCES doubleCascTreeCreator.cxx @@ -173,3 +168,8 @@ if(FastJet_FOUND) PUBLIC_LINK_LIBRARIES O2Physics::AnalysisCore O2Physics::PWGJECore FastJet::FastJet FastJet::Contrib O2Physics::EventFilteringUtils COMPONENT_NAME Analysis) endif() + +o2physics_add_dpl_workflow(hstrangederiveddata + SOURCES hStrangeDerivedData.cxx + PUBLIC_LINK_LIBRARIES O2::DCAFitter O2Physics::AnalysisCore O2Physics::EventFilteringUtils + COMPONENT_NAME Analysis) From e3d7be4c8eefa53be7e86835f1ce2dc4ef9f4ae1 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 19:34:14 +0800 Subject: [PATCH 05/10] Add files via upload --- PWGLF/DataModel/DrvCollisions.h | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/PWGLF/DataModel/DrvCollisions.h b/PWGLF/DataModel/DrvCollisions.h index 870a7273460..12cd12937d0 100644 --- a/PWGLF/DataModel/DrvCollisions.h +++ b/PWGLF/DataModel/DrvCollisions.h @@ -1,3 +1,13 @@ +// 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. #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" From 7e799f963d5dd7808763357150d6f16ca7bec1f6 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 19:48:43 +0800 Subject: [PATCH 06/10] Add files via upload --- PWGLF/DataModel/DrvCollisions.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/PWGLF/DataModel/DrvCollisions.h b/PWGLF/DataModel/DrvCollisions.h index 12cd12937d0..977dde9bb53 100644 --- a/PWGLF/DataModel/DrvCollisions.h +++ b/PWGLF/DataModel/DrvCollisions.h @@ -8,6 +8,8 @@ // 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. +#ifndef PWGLF_DATAMODEL_DRVCOLLISION_H_ +#define PWGLF_DATAMODEL_DRVCOLLISION_H_ #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" @@ -89,3 +91,4 @@ DECLARE_SOA_TABLE(BCandTime, "AOD", "BCANDTIME", drvcollision::Timestamp, drvcollision::RunNumber, drvcollision::GlobalBC); } // namespace o2::aod +#endif \ No newline at end of file From 462ac814e73888c82a1967f360c099705f4a1e6a Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 19:52:53 +0800 Subject: [PATCH 07/10] Add files via upload --- PWGLF/DataModel/DrvCollisions.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/PWGLF/DataModel/DrvCollisions.h b/PWGLF/DataModel/DrvCollisions.h index 977dde9bb53..d29c53fd4bc 100644 --- a/PWGLF/DataModel/DrvCollisions.h +++ b/PWGLF/DataModel/DrvCollisions.h @@ -91,4 +91,5 @@ DECLARE_SOA_TABLE(BCandTime, "AOD", "BCANDTIME", drvcollision::Timestamp, drvcollision::RunNumber, drvcollision::GlobalBC); } // namespace o2::aod -#endif \ No newline at end of file + +#endif From 388b8d56146e634581aee2a8c520a62f86360c69 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 20:06:29 +0800 Subject: [PATCH 08/10] Add files via upload --- PWGLF/DataModel/DrvCollisions.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PWGLF/DataModel/DrvCollisions.h b/PWGLF/DataModel/DrvCollisions.h index d29c53fd4bc..80f3fe463e7 100644 --- a/PWGLF/DataModel/DrvCollisions.h +++ b/PWGLF/DataModel/DrvCollisions.h @@ -92,4 +92,4 @@ DECLARE_SOA_TABLE(BCandTime, "AOD", "BCANDTIME", drvcollision::RunNumber, drvcollision::GlobalBC); } // namespace o2::aod -#endif +#endif // PWGLF_DATAMODEL_DRVCOLLISION_H_ From 9eb5e52d08c28bfd30243542d12044eafbbbcc93 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 20:20:26 +0800 Subject: [PATCH 09/10] Add files via upload --- PWGLF/DataModel/DrvCollisions.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/PWGLF/DataModel/DrvCollisions.h b/PWGLF/DataModel/DrvCollisions.h index 80f3fe463e7..6b2f1f3b034 100644 --- a/PWGLF/DataModel/DrvCollisions.h +++ b/PWGLF/DataModel/DrvCollisions.h @@ -8,8 +8,8 @@ // 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. -#ifndef PWGLF_DATAMODEL_DRVCOLLISION_H_ -#define PWGLF_DATAMODEL_DRVCOLLISION_H_ +#ifndef PWGLF_DATAMODEL_DRVCOLLISIONS_H_ +#define PWGLF_DATAMODEL_DRVCOLLISIONS_H_ #include "Framework/ASoA.h" #include "Framework/AnalysisDataModel.h" @@ -92,4 +92,4 @@ DECLARE_SOA_TABLE(BCandTime, "AOD", "BCANDTIME", drvcollision::RunNumber, drvcollision::GlobalBC); } // namespace o2::aod -#endif // PWGLF_DATAMODEL_DRVCOLLISION_H_ +#endif // PWGLF_DATAMODEL_DRVCOLLISIONS_H_ From e8e180e96a018907836d00cc38bd7cb2e2161067 Mon Sep 17 00:00:00 2001 From: gengjiabin12 <997406694@qq.com> Date: Sat, 27 Dec 2025 20:31:44 +0800 Subject: [PATCH 10/10] Add files via upload --- PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx | 1 + 1 file changed, 1 insertion(+) diff --git a/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx b/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx index 90200184b00..4a222a77877 100644 --- a/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx +++ b/PWGLF/TableProducer/Strangeness/hStrangeDerivedData.cxx @@ -31,6 +31,7 @@ #include #include +#include using namespace o2; using namespace o2::constants::math;