From 49b549d70ff35c30a0db032f5c6cb883815d411b Mon Sep 17 00:00:00 2001 From: creetz16 Date: Mon, 20 Jul 2026 18:11:26 +0200 Subject: [PATCH 1/7] Add option to use KFParticle for two-body vertex fit Add DCA of ITS matched track to SV to output table --- PWGLF/DataModel/Vtx3BodyTables.h | 9 + .../Nuspex/trackedHypertritonRecoTask.cxx | 203 +++++++++++++++--- PWGLF/Utils/decay3bodyBuilderHelper.h | 3 + 3 files changed, 185 insertions(+), 30 deletions(-) diff --git a/PWGLF/DataModel/Vtx3BodyTables.h b/PWGLF/DataModel/Vtx3BodyTables.h index efbbb037519..a2c8ad8a396 100644 --- a/PWGLF/DataModel/Vtx3BodyTables.h +++ b/PWGLF/DataModel/Vtx3BodyTables.h @@ -140,6 +140,10 @@ DECLARE_SOA_COLUMN(IsSurvEvSel, isSurvEvSel, int); //! flag if reco collisio DECLARE_SOA_COLUMN(IsReco, isreco, int); //! flag if candidate was reconstructed DECLARE_SOA_COLUMN(MotherLabel, motherLabel, int); //! label of the mother particle (signal: MC index, bkg: negative value) +// strangeness tracking information +DECLARE_SOA_COLUMN(ITSTrackDCAXYToSVXY, itsTrackDcaXYToSv, float); //! DCAxy of ITS track to SV +DECLARE_SOA_COLUMN(ITSTrackDCAZToSVXY, itsTrackDcaZToSv, float); //! DCAz of ITS track to SV + // Derived expressions // Momenta DECLARE_SOA_DYNAMIC_COLUMN(Pt, pt, //! 3 body pT in GeV/c @@ -258,6 +262,11 @@ DECLARE_SOA_TABLE(Vtx3BodyCovs, "AOD", "VTX3BODYCOV", //! vtx3body::CovProton, vtx3body::CovPion, vtx3body::CovDeuteron, vtx3body::VtxCovMat); +// strangeness tracked extra table +DECLARE_SOA_TABLE(Vtx3BodyTrackedInfo, "AOD", "VTX3BODYTR", //! + vtx3body::ITSTrackDCAXYToSVXY, + vtx3body::ITSTrackDCAZToSVXY); + // MC candidate table for analysis DECLARE_SOA_TABLE(McVtx3BodyDatas, "AOD", "MC3BODYDATA", //! o2::soa::Index<>, diff --git a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx index 8674757f203..352307d65a0 100644 --- a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx @@ -100,6 +100,7 @@ struct TrackedHypertritonRecoTask { Produces mcHypCands; Produces vtx3BodyDatas; Produces vtx3BodyCovs; + Produces vtx3BodyTrackedInfo; Produces mcVtx3BodyDatas; Service ccdb{}; @@ -124,7 +125,9 @@ struct TrackedHypertritonRecoTask { struct : ConfigurableGroup { std::string prefix = "twoBody"; + Configurable useKFParticle{"useKFParticle", false, "Use KFParticle to build the two-body candidate"}; Configurable useSelections{"useSelections", false, "Apply the two-body candidate selections"}; + Configurable kfSetTopologicalConstraint{"kfSetTopologicalConstraint", false, "Set topological vertex constraint in case of KFParticle reconstruction"}; Configurable maxEtaDaughters{"maxEtaDaughters", 1.e10f, "Maximum absolute daughter eta"}; Configurable minTPCNClsHe{"minTPCNClsHe", -1.f, "Minimum He TPC clusters"}; Configurable minTPCNClsPi{"minTPCNClsPi", -1.f, "Minimum pion TPC clusters"}; @@ -133,7 +136,7 @@ struct TrackedHypertritonRecoTask { Configurable minTPCInnerParamHe{"minTPCInnerParamHe", -1.f, "Minimum He TPC rigidity"}; Configurable minPt{"minPt", -1.f, "Minimum candidate transverse momentum"}; Configurable massWindow{"massWindow", 1.e10f, "Half-width of the hypertriton mass window"}; - Configurable maxDcaDaughters{"maxDcaDaughters", 1.e10f, "Maximum DCA between daughters"}; + Configurable maxChi2{"maxChi2", 1.e10f, "KFParticle: Maximum SV chi2, DCA fitter: Maximum DCA between daughters"}; Configurable minCosPA{"minCosPA", -2.f, "Minimum cosine of the pointing angle"}; Configurable minDcaHeToPV{"minDcaHeToPV", -1.f, "Minimum absolute He DCA to PV"}; Configurable minDcaPiToPV{"minDcaPiToPV", -1.f, "Minimum absolute pion DCA to PV"}; @@ -179,6 +182,8 @@ struct TrackedHypertritonRecoTask { Configurable maxCtau{"maxCtau", 100.f, "Maximum candidate c tau"}; Configurable minCosPA{"minCosPA", 0.9f, "Minimum candidate cosine of the pointing angle"}; Configurable maxChi2{"maxChi2", 100.f, "Maximum candidate chi2"}; + Configurable maxITSDCAxytrackToSV{"maxITSDCAxytrackToSV", 10.0, "Maximum distance of ITS matched track to SV in xy"}; + Configurable maxITSDCAztrackToSV{"maxITSDCAztrackToSV", 10.0, "Maximum distance of ITS matched track to SV in z"}; } threeBody; o2::vertexing::DCAFitterN<2> fitter2Body; @@ -196,6 +201,22 @@ struct TrackedHypertritonRecoTask { std::vector recoCollisionForMC; std::vector survivedMCEventSelection; + struct v0Candidate { + // daughter properties + std::array momHelium{}; + std::array momPion{}; + std::array posHelium{}; + std::array posPion{}; + // vertex properties + float mass; + float chi2; + float cosPA; + std::array decayVertex{}; + std::array momentum{}; + }; + + v0Candidate v0; + struct TwoBodyMCInfo { float genPt = -1.f; float genPhi = -1.f; @@ -536,14 +557,101 @@ struct TrackedHypertritonRecoTask { return (track.tpcSignal() - expected) / (expected * bbParamsHe[5]); } - template - void buildTwoBody(TTrack const& heTrack, TTrack const& piTrack, TCollision const& collision, float trackedClSize, TFillCandidate const& fillCandidate) + template + void fit2BodyWithKF(TCollision const& collision, + TTrack const& trackHelium, + TTrack const& trackPion, + TTrackParCov const& trackHeliumCov, + TTrackParCov const& trackPionCov) + { + // initialise KF primary vertex + KFVertex kfpVertex = createKFPVertexFromCollision(collision); + KFParticle kfpv(kfpVertex); + + // create KFParticle objects + KFParticle kfpHelium, kfpPion; + // helium + std::array xyz, pxpypz; + float xyzpxpypz[6]; + trackHeliumCov.getPxPyPzGlo(pxpypz); + trackHeliumCov.getXYZGlo(xyz); + for (int i = 0; i < 3; ++i) { + xyzpxpypz[i] = xyz[i]; + xyzpxpypz[i + 3] = pxpypz[i] * 2; + } + std::array cv{}; + trackHeliumCov.getCovXYZPxPyPzGlo(cv); + KFParticle kfHelium; + kfHelium.Create(xyzpxpypz, cv.data(), trackHelium.sign() * 2, constants::physics::MassHelium3); + // pion + kfpPion = createKFParticleFromTrackParCov(trackPionCov, trackPion.sign(), constants::physics::MassPionCharged); + + // construct V0 vertex + KFParticle KFV0; + int nDaughtersV0 = 2; + const KFParticle* DaughtersV0[2] = {&kfpHelium, &kfpPion}; + KFV0.SetConstructMethod(2); + try { + KFV0.Construct(DaughtersV0, nDaughtersV0); + } catch (std::runtime_error& e) { + LOG(debug) << "Failed to create V0 vertex." << e.what(); + return; + } + + // topological constraint + if (twoBody.kfSetTopologicalConstraint) { + KFV0.SetProductionVertex(kfpv); + KFV0.TransportToDecayVertex(); + } + + // get vertex position and momentum + v0.decayVertex[0] = KFV0.GetX(); + v0.decayVertex[1] = KFV0.GetY(); + v0.decayVertex[2] = KFV0.GetZ(); + v0.momentum[0] = KFV0.GetPx(); + v0.momentum[1] = KFV0.GetPy(); + v0.momentum[2] = KFV0.GetPz(); + + // transport all daughter tracks to hypertriton vertex + // float position[3]; + // for (int i; i < 3; i++) { + // position[i] = v0.decayVertex[i]; + // } + kfpHelium.TransportToPoint(v0.decayVertex.data()); + kfpPion.TransportToPoint(v0.decayVertex.data()); + + // daughter positions + v0.posHelium[0] = kfpHelium.GetX(); + v0.posHelium[1] = kfpHelium.GetY(); + v0.posHelium[2] = kfpHelium.GetZ(); + v0.posPion[0] = kfpPion.GetX(); + v0.posPion[1] = kfpPion.GetY(); + v0.posPion[2] = kfpPion.GetZ(); + + // daughter momenta + v0.momHelium[0] = kfpHelium.GetPx(); + v0.momHelium[1] = kfpHelium.GetPy(); + v0.momHelium[2] = kfpHelium.GetPz(); + v0.momPion[0] = kfpPion.GetPx(); + v0.momPion[1] = kfpPion.GetPy(); + v0.momPion[2] = kfpPion.GetPz(); + + // candidate mass + float mass, massErr; + KFV0.GetMass(mass, massErr); + v0.mass = mass; + + // vertex chi2 + v0.chi2 = KFV0.GetChi2() / KFV0.GetNDF(); + } + + template + void fit2bodyWithDCAFitter(TTrackParCov const& trackHeliumCov, + TTrackParCov const& trackPionCov) { - auto heTrackCov = getTrackParCov(heTrack); - auto piTrackCov = getTrackParCov(piTrack); int nCandidates = 0; try { - nCandidates = fitter2Body.process(heTrackCov, piTrackCov); + nCandidates = fitter2Body.process(trackHeliumCov, trackPionCov); } catch (...) { LOG(error) << "Exception while fitting a tracked two-body candidate"; return; @@ -552,36 +660,57 @@ struct TrackedHypertritonRecoTask { return; } - std::array heMomentum{}; - std::array piMomentum{}; - fitter2Body.getTrack(0).getPxPyPzGlo(heMomentum); - fitter2Body.getTrack(1).getPxPyPzGlo(piMomentum); - for (std::size_t i = 0; i < heMomentum.size(); ++i) { - heMomentum[i] *= 2.f; - } - std::array momentum{heMomentum[0] + piMomentum[0], heMomentum[1] + piMomentum[1], heMomentum[2] + piMomentum[2]}; - if (twoBody.useSelections && std::hypot(momentum[0], momentum[1]) < twoBody.minPt) { - return; + // get daughter momenta + fitter2Body.getTrack(0).getPxPyPzGlo(v0.momHelium); + fitter2Body.getTrack(1).getPxPyPzGlo(v0.momPion); + + for (std::size_t i = 0; i < v0.momHelium.size(); ++i) { + v0.momHelium[i] *= 2.f; } - const float heMomentum2 = RecoDecay::sumOfSquares(heMomentum[0], heMomentum[1], heMomentum[2]); - const float piMomentum2 = RecoDecay::sumOfSquares(piMomentum[0], piMomentum[1], piMomentum[2]); - const float candidateMomentum2 = RecoDecay::sumOfSquares(momentum[0], momentum[1], momentum[2]); + // compute candidate momentum + v0.momentum = {v0.momHelium[0] + v0.momPion[0], v0.momHelium[1] + v0.momPion[1], v0.momHelium[2] + v0.momPion[2]}; + + // compute candidate mass + const float heMomentum2 = RecoDecay::sumOfSquares(v0.momHelium[0], v0.momHelium[1], v0.momHelium[2]); + const float piMomentum2 = RecoDecay::sumOfSquares(v0.momPion[0], v0.momPion[1], v0.momPion[2]); + const float candidateMomentum2 = RecoDecay::sumOfSquares(v0.momentum[0], v0.momentum[1], v0.momentum[2]); const float heEnergy = std::sqrt(heMomentum2 + constants::physics::MassHelium3 * constants::physics::MassHelium3); const float piEnergy = std::sqrt(piMomentum2 + constants::physics::MassPionCharged * constants::physics::MassPionCharged); - const float mass = std::sqrt((heEnergy + piEnergy) * (heEnergy + piEnergy) - candidateMomentum2); - if (twoBody.useSelections && std::abs(mass - constants::physics::MassHyperTriton) > twoBody.massWindow) { - return; - } + v0.mass = std::sqrt((heEnergy + piEnergy) * (heEnergy + piEnergy) - candidateMomentum2); + // get SV position const auto& secondaryVertex = fitter2Body.getPCACandidate(); + for (int i = 0; i < 3; i++) { + v0.decayVertex[i] = secondaryVertex[i]; + } + v0.chi2 = std::sqrt(fitter2Body.getChi2AtPCACandidate()); + } + + template + void buildTwoBody(TTrack const& heTrack, TTrack const& piTrack, TCollision const& collision, float trackedClSize, TFillCandidate const& fillCandidate) + { const std::array primaryVertex{collision.posX(), collision.posY(), collision.posZ()}; - const std::array decayVertex{static_cast(secondaryVertex[0]), static_cast(secondaryVertex[1]), static_cast(secondaryVertex[2])}; - const float dcaDaughters = std::sqrt(fitter2Body.getChi2AtPCACandidate()); - if (twoBody.useSelections && (dcaDaughters > twoBody.maxDcaDaughters || RecoDecay::cpa(primaryVertex, decayVertex, momentum) < twoBody.minCosPA)) { + + auto heTrackCov = getTrackParCov(heTrack); + auto piTrackCov = getTrackParCov(piTrack); + + if (twoBody.useKFParticle) { + fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov); + } else { + fit2bodyWithDCAFitter(heTrackCov, piTrackCov); + } + + v0.cosPA = RecoDecay::cpa(primaryVertex, v0.decayVertex, v0.momentum); + if (twoBody.useSelections && + (std::hypot(v0.momentum[0], v0.momentum[1]) < twoBody.minPt || + std::abs(v0.mass - constants::physics::MassHyperTriton) > twoBody.massWindow || + v0.chi2 > twoBody.maxChi2 || + v0.cosPA < twoBody.minCosPA)) { return; } + // Do propagation with Propagator including material interactions in all cases (KFParticle propagation would not include material) std::array dcaInfo{}; o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, heTrackCov, 2.f, fitter2Body.getMatCorrType(), &dcaInfo); const float dcaHe = dcaInfo[0]; @@ -605,10 +734,10 @@ struct TrackedHypertritonRecoTask { fillCandidate(collision.centFT0A(), collision.centFT0C(), collision.centFT0M(), collision.posX(), collision.posY(), collision.posZ(), runNumber, heTrack.sign() > 0, - std::hypot(heMomentum[0], heMomentum[1]), std::atan2(heMomentum[1], heMomentum[0]), RecoDecay::eta(heMomentum), - std::hypot(piMomentum[0], piMomentum[1]), std::atan2(piMomentum[1], piMomentum[0]), RecoDecay::eta(piMomentum), - secondaryVertex[0], secondaryVertex[1], secondaryVertex[2], - dcaDaughters, dcaHe, dcaPi, + std::hypot(v0.momHelium[0], v0.momHelium[1]), std::atan2(v0.momHelium[1], v0.momHelium[0]), RecoDecay::eta(v0.momHelium), + std::hypot(v0.momPion[0], v0.momPion[1]), std::atan2(v0.momPion[1], v0.momPion[0]), RecoDecay::eta(v0.momPion), + v0.decayVertex[0], v0.decayVertex[1], v0.decayVertex[2], + v0.chi2, dcaHe, dcaPi, nSigmaHe3(heTrack), heTrack.tpcNClsFound(), piTrack.tpcNClsFound(), static_cast(heTrack.tpcNClsFindable()) - heTrack.tpcNClsFindableMinusPID(), static_cast(piTrack.tpcNClsFindable()) - piTrack.tpcNClsFindableMinusPID(), @@ -662,6 +791,7 @@ struct TrackedHypertritonRecoTask { static_cast(candidate.tpcNCl[0]), static_cast(candidate.tpcNCl[1]), static_cast(candidate.tpcNCl[2]), static_cast(candidate.pidForTrackingDeuteron)); vtx3BodyCovs(candidate.covProton, candidate.covPion, candidate.covDeuteron, candidate.covariance); + vtx3BodyTrackedInfo(candidate.itsTrackDCAToSV[0], candidate.itsTrackDCAToSV[1]); } void fillThreeBodyMCTable(ThreeBodyMCInfo const& info) @@ -776,12 +906,25 @@ struct TrackedHypertritonRecoTask { if (decay3Body.collisionId() < 0 || !goodCollision[decay3Body.collisionId()] || (skimmedProcessing && !zorroDecision[decay3Body.collisionId()][kTracked3Body])) { continue; } + const auto collision = decay3Body.collision_as(); const auto trackPositive = decay3Body.track0_as(); const auto trackNegative = decay3Body.track1_as(); const auto trackDeuteron = decay3Body.track2_as(); const auto trackProton = trackDeuteron.sign() > 0 ? trackPositive : trackNegative; const auto trackPion = trackDeuteron.sign() > 0 ? trackNegative : trackPositive; + + // get DCA of ITS track to SV + const auto itsTrack = tracked3Body.itsTrack_as(); + auto itsTrackParCov = getTrackParCov(itsTrack); + std::array dcaInfoItsTrack{}; + o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, itsTrackParCov, 2.f, fitter2Body.getMatCorrType(), &dcaInfoItsTrack); + builder3Body.decay3body.itsTrackDCAToSV[0] = dcaInfoItsTrack[0]; + builder3Body.decay3body.itsTrackDCAToSV[1] = dcaInfoItsTrack[1]; + if (threeBody.useSelections && (builder3Body.decay3body.itsTrackDCAToSV[0] > threeBody.maxITSDCAxytrackToSV || builder3Body.decay3body.itsTrackDCAToSV[1] > threeBody.maxITSDCAztrackToSV)) { + continue; + } + if (builder3Body.buildDecay3BodyCandidate(collision, trackProton, trackPion, trackDeuteron, decay3Body.globalIndex(), deuteronTOFNSigma(collision, trackDeuteron), tracked3Body.itsClsSize(), threeBody.useKFParticle, threeBody.setTopologicalConstraint, diff --git a/PWGLF/Utils/decay3bodyBuilderHelper.h b/PWGLF/Utils/decay3bodyBuilderHelper.h index a354b92e788..32bcd33d0de 100644 --- a/PWGLF/Utils/decay3bodyBuilderHelper.h +++ b/PWGLF/Utils/decay3bodyBuilderHelper.h @@ -91,6 +91,9 @@ struct decay3bodyCandidate { float covPion[21] = {0.0f}; float covDeuteron[21] = {0.0f}; float covariance[21] = {0.0f}; + + // strangeness tracking + std::array itsTrackDCAToSV; }; //_______________________________________________________________________ From ee5a82c543ed90dfde49957ba74c2e7f7f167a8a Mon Sep 17 00:00:00 2001 From: creetz16 Date: Tue, 21 Jul 2026 11:12:21 +0200 Subject: [PATCH 2/7] Trigger formatting checks From ea907871728f93b90e582ebdad343e87b731e37b Mon Sep 17 00:00:00 2001 From: creetz16 Date: Tue, 21 Jul 2026 15:29:35 +0200 Subject: [PATCH 3/7] Fix bugs --- .../Nuspex/decay3bodybuilder.cxx | 8 +- .../Nuspex/trackedHypertritonRecoTask.cxx | 35 ++--- PWGLF/Utils/decay3bodyBuilderHelper.h | 130 ++++++++---------- 3 files changed, 77 insertions(+), 96 deletions(-) diff --git a/PWGLF/TableProducer/Nuspex/decay3bodybuilder.cxx b/PWGLF/TableProducer/Nuspex/decay3bodybuilder.cxx index 4a0a22ce33e..31fb7c63a0f 100644 --- a/PWGLF/TableProducer/Nuspex/decay3bodybuilder.cxx +++ b/PWGLF/TableProducer/Nuspex/decay3bodybuilder.cxx @@ -1115,10 +1115,10 @@ struct decay3bodyBuilder { registry.fill(HIST("Counters/hTableBuildingStatistics"), kVtx3BodyDatas); } if (mEnabledTables[kVtx3BodyCovs]) { - products.vtx3bodycovs(helper.decay3body.covProton, - helper.decay3body.covPion, - helper.decay3body.covDeuteron, - helper.decay3body.covariance); + products.vtx3bodycovs(helper.decay3body.covProton.data(), + helper.decay3body.covPion.data(), + helper.decay3body.covDeuteron.data(), + helper.decay3body.covariance.data()); registry.fill(HIST("Counters/hTableBuildingStatistics"), kVtx3BodyCovs); } if (mEnabledTables[kMcVtx3BodyDatas]) { diff --git a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx index 352307d65a0..a14d5ec80a8 100644 --- a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx @@ -70,6 +70,8 @@ using namespace o2; using namespace o2::framework; +o2::common::core::MetadataHelper metadataInfo{}; + namespace { using Collisions = soa::Join; @@ -94,8 +96,6 @@ enum ZorroTrigger : std::size_t { } // namespace struct TrackedHypertritonRecoTask { - o2::common::core::MetadataHelper metadataInfo{}; - Produces dataHypCands; Produces mcHypCands; Produces vtx3BodyDatas; @@ -208,9 +208,9 @@ struct TrackedHypertritonRecoTask { std::array posHelium{}; std::array posPion{}; // vertex properties - float mass; - float chi2; - float cosPA; + float mass{}; + float chi2{}; + float cosPA{}; std::array decayVertex{}; std::array momentum{}; }; @@ -565,14 +565,14 @@ struct TrackedHypertritonRecoTask { TTrackParCov const& trackPionCov) { // initialise KF primary vertex - KFVertex kfpVertex = createKFPVertexFromCollision(collision); - KFParticle kfpv(kfpVertex); + KFParticle kfpv(createKFPVertexFromCollision(collision)); // create KFParticle objects KFParticle kfpHelium, kfpPion; // helium - std::array xyz, pxpypz; - float xyzpxpypz[6]; + std::array xyz{}; + std::array pxpypz{}; + std::array xyzpxpypz{}; trackHeliumCov.getPxPyPzGlo(pxpypz); trackHeliumCov.getXYZGlo(xyz); for (int i = 0; i < 3; ++i) { @@ -582,7 +582,7 @@ struct TrackedHypertritonRecoTask { std::array cv{}; trackHeliumCov.getCovXYZPxPyPzGlo(cv); KFParticle kfHelium; - kfHelium.Create(xyzpxpypz, cv.data(), trackHelium.sign() * 2, constants::physics::MassHelium3); + kfHelium.Create(xyzpxpypz.data(), cv.data(), trackHelium.sign() * 2, constants::physics::MassHelium3); // pion kfpPion = createKFParticleFromTrackParCov(trackPionCov, trackPion.sign(), constants::physics::MassPionCharged); @@ -591,12 +591,7 @@ struct TrackedHypertritonRecoTask { int nDaughtersV0 = 2; const KFParticle* DaughtersV0[2] = {&kfpHelium, &kfpPion}; KFV0.SetConstructMethod(2); - try { - KFV0.Construct(DaughtersV0, nDaughtersV0); - } catch (std::runtime_error& e) { - LOG(debug) << "Failed to create V0 vertex." << e.what(); - return; - } + KFV0.Construct(DaughtersV0, nDaughtersV0); // topological constraint if (twoBody.kfSetTopologicalConstraint) { @@ -637,7 +632,8 @@ struct TrackedHypertritonRecoTask { v0.momPion[2] = kfpPion.GetPz(); // candidate mass - float mass, massErr; + float mass{}; + float massErr{}; KFV0.GetMass(mass, massErr); v0.mass = mass; @@ -790,7 +786,7 @@ struct TrackedHypertritonRecoTask { candidate.averageITSClSize[0], candidate.averageITSClSize[1], candidate.averageITSClSize[2], static_cast(candidate.tpcNCl[0]), static_cast(candidate.tpcNCl[1]), static_cast(candidate.tpcNCl[2]), static_cast(candidate.pidForTrackingDeuteron)); - vtx3BodyCovs(candidate.covProton, candidate.covPion, candidate.covDeuteron, candidate.covariance); + vtx3BodyCovs(candidate.covProton.data(), candidate.covPion.data(), candidate.covDeuteron.data(), candidate.covariance.data()); vtx3BodyTrackedInfo(candidate.itsTrackDCAToSV[0], candidate.itsTrackDCAToSV[1]); } @@ -1130,7 +1126,6 @@ struct TrackedHypertritonRecoTask { WorkflowSpec defineDataProcessing(ConfigContext const& cfgc) { - auto metadataInfo = o2::common::core::MetadataHelper{}; metadataInfo.initMetadata(cfgc); - return WorkflowSpec{adaptAnalysisTask(cfgc, std::move(metadataInfo))}; + return WorkflowSpec{adaptAnalysisTask(cfgc)}; } diff --git a/PWGLF/Utils/decay3bodyBuilderHelper.h b/PWGLF/Utils/decay3bodyBuilderHelper.h index 32bcd33d0de..1e9f35f788c 100644 --- a/PWGLF/Utils/decay3bodyBuilderHelper.h +++ b/PWGLF/Utils/decay3bodyBuilderHelper.h @@ -38,9 +38,7 @@ #include #include -namespace o2 -{ -namespace pwglf +namespace o2::pwglf { //_______________________________________________________________________ @@ -54,46 +52,46 @@ struct decay3bodyCandidate { int deuteronID = -1; // daughter properties - std::array momProton = {0.0f, 0.0f, 0.0f}; - std::array momPion = {0.0f, 0.0f, 0.0f}; - std::array momDeuteron = {0.0f, 0.0f, 0.0f}; - std::array posProton = {0.0f, 0.0f, 0.0f}; - std::array posPion = {0.0f, 0.0f, 0.0f}; - std::array posDeuteron = {0.0f, 0.0f, 0.0f}; - float xProton = 0.0f; - float xPion = 0.0f; - float xDeuteron = 0.0f; - std::array trackDCAxyToPV = {0.0f, 0.0f, 0.0f}; // 0 - proton, 1 - pion, 2 - deuteron - std::array trackDCAToPV = {0.0f, 0.0f, 0.0f}; // 0 - proton, 1 - pion, 2 - deuteron - std::array trackDCAxyToPVprop = {0.0f, 0.0f, 0.0f}; // 0 - proton, 1 - pion, 2 - deuteron - std::array trackDCAToPVprop = {0.0f, 0.0f, 0.0f}; // 0 - proton, 1 - pion, 2 - deuteron - std::array tpcNsigma = {0.0f, 0.0f, 0.0f, 0.0f}; // 0 - proton, 1 - pion, 2 - deuteron, 3 - bach with pion hyp - double tofNsigmaDeuteron = 0.0f; - std::array averageITSClSize = {0.0f, 0.0f, 0.0f}; // 0 - proton, 1 - pion, 2 - deuteron - std::array tpcNCl = {0.0f, 0.0f, 0.0f}; // 0 - proton, 1 - pion, 2 - deuteron - int pidForTrackingDeuteron = 0; + std::array momProton{}; + std::array momPion{}; + std::array momDeuteron{}; + std::array posProton{}; + std::array posPion{}; + std::array posDeuteron{}; + float xProton{}; + float xPion{}; + float xDeuteron{}; + std::array trackDCAxyToPV{}; // 0 - proton, 1 - pion, 2 - deuteron + std::array trackDCAToPV{}; // 0 - proton, 1 - pion, 2 - deuteron + std::array trackDCAxyToPVprop{}; // 0 - proton, 1 - pion, 2 - deuteron + std::array trackDCAToPVprop{}; // 0 - proton, 1 - pion, 2 - deuteron + std::array tpcNsigma{}; // 0 - proton, 1 - pion, 2 - deuteron, 3 - bach with pion hyp + double tofNsigmaDeuteron{}; + std::array averageITSClSize{}; // 0 - proton, 1 - pion, 2 - deuteron + std::array tpcNCl{}; // 0 - proton, 1 - pion, 2 - deuteron + int pidForTrackingDeuteron{}; // vertex properties - float mass; - float massV0; - int sign; - float momentum[3]; - float position[3]; - float chi2 = 0.0f; - float trackedClSize = 0.0f; - float cosPA = 0.0f; // cosine of pointing angle - float ctau = 0.0f; // ctau of the candidate - float daughterDCAtoSVaverage = 0.0f; // average of quadratic sum of daughter DCAs to SV - std::array daughterDCAtoSV = {0.0f, 0.0f, 0.0f}; // 0 - pos, 1 - neg, 2 - bach + float mass{}; + float massV0{}; + int sign{}; + std::array momentum{}; + std::array position{}; + float chi2{}; + float trackedClSize{}; + float cosPA{}; // cosine of pointing angle + float ctau{}; // ctau of the candidate + float daughterDCAtoSVaverage{}; // average of quadratic sum of daughter DCAs to SV + std::array daughterDCAtoSV{}; // 0 - pos, 1 - neg, 2 - bach // covariance matrix - float covProton[21] = {0.0f}; - float covPion[21] = {0.0f}; - float covDeuteron[21] = {0.0f}; - float covariance[21] = {0.0f}; + std::array covProton{}; + std::array covPion{}; + std::array covDeuteron{}; + std::array covariance{}; // strangeness tracking - std::array itsTrackDCAToSV; + std::array itsTrackDCAToSV{}; }; //_______________________________________________________________________ @@ -166,7 +164,7 @@ class decay3bodyBuilderHelper float maxCtau; float minCosPA; float maxChi2; - } decay3bodyselections; + } decay3bodyselections{}; // SVertexer selection criteria struct { @@ -180,7 +178,7 @@ class decay3bodyBuilderHelper float maxTgl3Body; float maxDCAXY3Body; float maxDCAZ3Body; - } svertexerselections; + } svertexerselections{}; //_______________________________________________________________________ // build Decay3body from three tracks, including V0 building. @@ -298,8 +296,8 @@ class decay3bodyBuilderHelper //_______________________________________________________________________ // daughter track DCA to PV associated with decay3body --> computed with KFParticle - float pvXY[2] = {pvX, pvY}; - float pv[3] = {pvX, pvY, pvZ}; + std::array pvXY = {pvX, pvY}; + std::array pv = {pvX, pvY, pvZ}; auto trackParCovProtonCopy = trackParCovProton; auto trackParCovPionCopy = trackParCovPion; auto trackParCovDeuteronCopy = trackParCovDeuteron; @@ -308,14 +306,14 @@ class decay3bodyBuilderHelper KFParticle kfdeuteron = createKFParticleFromTrackParCov(trackParCovDeuteronCopy, trackDeuteron.sign(), constants::physics::MassDeuteron); // proton DCA to PV - decay3body.trackDCAxyToPV[0] = kfproton.GetDistanceFromVertexXY(pvXY); - decay3body.trackDCAToPV[0] = kfproton.GetDistanceFromVertex(pv); + decay3body.trackDCAxyToPV[0] = kfproton.GetDistanceFromVertexXY(pvXY.data()); + decay3body.trackDCAToPV[0] = kfproton.GetDistanceFromVertex(pv.data()); // pion DCA to PV - decay3body.trackDCAxyToPV[1] = kfpion.GetDistanceFromVertexXY(pvXY); - decay3body.trackDCAToPV[1] = kfpion.GetDistanceFromVertex(pv); + decay3body.trackDCAxyToPV[1] = kfpion.GetDistanceFromVertexXY(pvXY.data()); + decay3body.trackDCAToPV[1] = kfpion.GetDistanceFromVertex(pv.data()); // deuteron DCA to PV - decay3body.trackDCAxyToPV[2] = kfdeuteron.GetDistanceFromVertexXY(pvXY); - decay3body.trackDCAToPV[2] = kfdeuteron.GetDistanceFromVertex(pv); + decay3body.trackDCAxyToPV[2] = kfdeuteron.GetDistanceFromVertexXY(pvXY.data()); + decay3body.trackDCAToPV[2] = kfdeuteron.GetDistanceFromVertex(pv.data()); // selection if (useSelections) { if (decay3body.trackDCAToPV[0] < decay3bodyselections.minDCAProtonToPV) { @@ -441,14 +439,14 @@ class decay3bodyBuilderHelper } // rapidity - float rapidity = RecoDecay::y(std::array{decay3body.momentum[0], decay3body.momentum[1], decay3body.momentum[2]}, o2::constants::physics::MassHyperTriton); + float rapidity = RecoDecay::y(decay3body.momentum, o2::constants::physics::MassHyperTriton); if (std::fabs(rapidity) > decay3bodyselections.maxRapidity) { decay3body = {}; return false; } // pT - float pT = RecoDecay::pt(std::array{decay3body.momentum[0], decay3body.momentum[1], decay3body.momentum[2]}); + float pT = RecoDecay::pt(decay3body.momentum); if (pT < decay3bodyselections.minPt || pT > decay3bodyselections.maxPt) { decay3body = {}; return false; @@ -468,7 +466,7 @@ class decay3bodyBuilderHelper } // pointing angle - float cpa = RecoDecay::cpa(std::array{pvX, pvY, pvZ}, std::array{decay3body.position[0], decay3body.position[1], decay3body.position[2]}, std::array{decay3body.momentum[0], decay3body.momentum[1], decay3body.momentum[2]}); + float cpa = RecoDecay::cpa(std::array{pvX, pvY, pvZ}, decay3body.position, decay3body.momentum); if (useSelections) { if (cpa < decay3bodyselections.minCosPA) { decay3body = {}; @@ -558,8 +556,7 @@ class decay3bodyBuilderHelper auto trackParCovDeuteron = getTrackParCov(trackDeuteron); // initialise KF primary vertex - KFVertex kfpVertex = createKFPVertexFromCollision(collision); - KFParticle kfpv(kfpVertex); + KFParticle kfpv(createKFPVertexFromCollision(collision)); // create KFParticle objects KFParticle kfpProton, kfpPion, kfpDeuteron; @@ -609,9 +606,9 @@ class decay3bodyBuilderHelper decay3body.sign = KFH3L.GetQ() / std::abs(KFH3L.GetQ()); // transport all daughter tracks to hypertriton vertex - kfpProton.TransportToPoint(decay3body.position); - kfpPion.TransportToPoint(decay3body.position); - kfpDeuteron.TransportToPoint(decay3body.position); + kfpProton.TransportToPoint(decay3body.position.data()); + kfpPion.TransportToPoint(decay3body.position.data()); + kfpDeuteron.TransportToPoint(decay3body.position.data()); // daughter positions decay3body.posProton[0] = kfpProton.GetX(); @@ -651,10 +648,8 @@ class decay3bodyBuilderHelper // caluclate covariance matrices if (calculateCovariance) { // candidate covariance matrix - std::array covKF; for (int i = 0; i < 21; i++) { // get covariance matrix elements (lower triangle) - covKF[i] = KFH3L.GetCovariance(i); - decay3body.covariance[i] = covKF[i]; + decay3body.covariance[i] = KFH3L.GetCovariance(i); } // daughter track covariance matrices for (int i = 0; i < 21; i++) { // get covariance matrix elements (lower triangle) @@ -738,21 +733,13 @@ class decay3bodyBuilderHelper decay3body.covariance[4] = covVtxV(2, 1); decay3body.covariance[5] = covVtxV(2, 2); // daughter covariance matrices - std::array covTproton = {0.}; - std::array covTpion = {0.}; - std::array covTdeuteron = {0.}; - propagatedTrackProton.getCovXYZPxPyPzGlo(covTproton); - propagatedTrackPion.getCovXYZPxPyPzGlo(covTpion); - propagatedTrackDeuteron.getCovXYZPxPyPzGlo(covTdeuteron); - for (int i = 0; i < 21; i++) { - decay3body.covProton[i] = covTproton[i]; - decay3body.covPion[i] = covTpion[i]; - decay3body.covDeuteron[i] = covTdeuteron[i]; - } + propagatedTrackProton.getCovXYZPxPyPzGlo(decay3body.covProton); + propagatedTrackPion.getCovXYZPxPyPzGlo(decay3body.covPion); + propagatedTrackDeuteron.getCovXYZPxPyPzGlo(decay3body.covDeuteron); // candidate momentum covairance matrix constexpr int MomInd[6] = {9, 13, 14, 18, 19, 20}; // cov matrix elements for momentum component for (int i = 0; i < 6; i++) { - decay3body.covariance[MomInd[i]] = covTproton[MomInd[i]] + covTpion[MomInd[i]] + covTdeuteron[MomInd[i]]; + decay3body.covariance[MomInd[i]] = decay3body.covProton[MomInd[i]] + decay3body.covPion[MomInd[i]] + decay3body.covDeuteron[MomInd[i]]; } /// WARNING: position-momentum covariances are not calculated in the DCAFitter - remain zero } @@ -898,7 +885,6 @@ class decay3bodyBuilderHelper } }; -} // namespace pwglf -} // namespace o2 +} // namespace o2::pwglf #endif // PWGLF_UTILS_DECAY3BODYBUILDERHELPER_H_ From b73c94509d8def3e8288ba108e0835dc896ad828 Mon Sep 17 00:00:00 2001 From: creetz16 Date: Tue, 21 Jul 2026 15:43:58 +0200 Subject: [PATCH 4/7] More fixes --- PWGLF/Utils/decay3bodyBuilderHelper.h | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/PWGLF/Utils/decay3bodyBuilderHelper.h b/PWGLF/Utils/decay3bodyBuilderHelper.h index 1e9f35f788c..66646a38cad 100644 --- a/PWGLF/Utils/decay3bodyBuilderHelper.h +++ b/PWGLF/Utils/decay3bodyBuilderHelper.h @@ -638,7 +638,8 @@ class decay3bodyBuilderHelper decay3body.mass = mass; // V0 mass - float massV0, massV0Err; + float massV0{}; + float massV0Err{}; KFV0.GetMass(massV0, massV0Err); decay3body.massV0 = massV0; @@ -658,8 +659,6 @@ class decay3bodyBuilderHelper decay3body.covDeuteron[i] = kfpDeuteron.GetCovariance(i); } } - - return; } //_______________________________________________________________________ @@ -873,8 +872,6 @@ class decay3bodyBuilderHelper std::abs(dca.getY()) > svertexerselections.maxDCAXY3Body || std::abs(dca.getZ()) > svertexerselections.maxDCAZ3Body) { return; } - - return; } private: From a9ad0810d19a2e7ed1496c70efd633a3e37aca60 Mon Sep 17 00:00:00 2001 From: creetz16 Date: Tue, 21 Jul 2026 16:48:25 +0200 Subject: [PATCH 5/7] Don't fill 2-body tables if vertex fit fails Fix computation of ITS track DCA to SV --- .../Nuspex/trackedHypertritonRecoTask.cxx | 49 +++++++++++-------- 1 file changed, 29 insertions(+), 20 deletions(-) diff --git a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx index a14d5ec80a8..e9a5fc56f65 100644 --- a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx @@ -558,7 +558,7 @@ struct TrackedHypertritonRecoTask { } template - void fit2BodyWithKF(TCollision const& collision, + bool fit2BodyWithKF(TCollision const& collision, TTrack const& trackHelium, TTrack const& trackPion, TTrackParCov const& trackHeliumCov, @@ -591,7 +591,12 @@ struct TrackedHypertritonRecoTask { int nDaughtersV0 = 2; const KFParticle* DaughtersV0[2] = {&kfpHelium, &kfpPion}; KFV0.SetConstructMethod(2); - KFV0.Construct(DaughtersV0, nDaughtersV0); + try { + KFV0.Construct(DaughtersV0, nDaughtersV0); + } catch (std::runtime_error& e) { + LOG(debug) << "Failed to create V0 vertex." << e.what(); + return false; + } // topological constraint if (twoBody.kfSetTopologicalConstraint) { @@ -639,10 +644,12 @@ struct TrackedHypertritonRecoTask { // vertex chi2 v0.chi2 = KFV0.GetChi2() / KFV0.GetNDF(); + + return true; } template - void fit2bodyWithDCAFitter(TTrackParCov const& trackHeliumCov, + bool fit2bodyWithDCAFitter(TTrackParCov const& trackHeliumCov, TTrackParCov const& trackPionCov) { int nCandidates = 0; @@ -650,10 +657,10 @@ struct TrackedHypertritonRecoTask { nCandidates = fitter2Body.process(trackHeliumCov, trackPionCov); } catch (...) { LOG(error) << "Exception while fitting a tracked two-body candidate"; - return; + return false; } if (nCandidates == 0) { - return; + return false; } // get daughter momenta @@ -681,6 +688,8 @@ struct TrackedHypertritonRecoTask { v0.decayVertex[i] = secondaryVertex[i]; } v0.chi2 = std::sqrt(fitter2Body.getChi2AtPCACandidate()); + + return true; } template @@ -691,10 +700,10 @@ struct TrackedHypertritonRecoTask { auto heTrackCov = getTrackParCov(heTrack); auto piTrackCov = getTrackParCov(piTrack); - if (twoBody.useKFParticle) { - fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov); - } else { - fit2bodyWithDCAFitter(heTrackCov, piTrackCov); + if (twoBody.useKFParticle && !fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov)) { + return; + } else if (!fit2bodyWithDCAFitter(heTrackCov, piTrackCov)) { + return; } v0.cosPA = RecoDecay::cpa(primaryVertex, v0.decayVertex, v0.momentum); @@ -910,22 +919,22 @@ struct TrackedHypertritonRecoTask { const auto trackProton = trackDeuteron.sign() > 0 ? trackPositive : trackNegative; const auto trackPion = trackDeuteron.sign() > 0 ? trackNegative : trackPositive; - // get DCA of ITS track to SV - const auto itsTrack = tracked3Body.itsTrack_as(); - auto itsTrackParCov = getTrackParCov(itsTrack); - std::array dcaInfoItsTrack{}; - o2::base::Propagator::Instance()->propagateToDCABxByBz({collision.posX(), collision.posY(), collision.posZ()}, itsTrackParCov, 2.f, fitter2Body.getMatCorrType(), &dcaInfoItsTrack); - builder3Body.decay3body.itsTrackDCAToSV[0] = dcaInfoItsTrack[0]; - builder3Body.decay3body.itsTrackDCAToSV[1] = dcaInfoItsTrack[1]; - if (threeBody.useSelections && (builder3Body.decay3body.itsTrackDCAToSV[0] > threeBody.maxITSDCAxytrackToSV || builder3Body.decay3body.itsTrackDCAToSV[1] > threeBody.maxITSDCAztrackToSV)) { - continue; - } - if (builder3Body.buildDecay3BodyCandidate(collision, trackProton, trackPion, trackDeuteron, decay3Body.globalIndex(), deuteronTOFNSigma(collision, trackDeuteron), tracked3Body.itsClsSize(), threeBody.useKFParticle, threeBody.setTopologicalConstraint, threeBody.useSelections, threeBody.useChi2Selection, threeBody.useTPCforPion, threeBody.acceptTPCOnly, threeBody.askOnlyITSMatch, threeBody.calculateCovariance)) { + // get DCA of ITS track to SV + const auto itsTrack = tracked3Body.itsTrack_as(); + auto itsTrackParCov = getTrackParCov(itsTrack); + std::array dcaInfoItsTrack{}; + o2::base::Propagator::Instance()->propagateToDCABxByBz({builder3Body.decay3body.position[0], builder3Body.decay3body.position[1], builder3Body.decay3body.position[2]}, itsTrackParCov, 2.f, fitter2Body.getMatCorrType(), &dcaInfoItsTrack); + builder3Body.decay3body.itsTrackDCAToSV[0] = dcaInfoItsTrack[0]; + builder3Body.decay3body.itsTrackDCAToSV[1] = dcaInfoItsTrack[1]; + if (threeBody.useSelections && (builder3Body.decay3body.itsTrackDCAToSV[0] > threeBody.maxITSDCAxytrackToSV || builder3Body.decay3body.itsTrackDCAToSV[1] > threeBody.maxITSDCAztrackToSV)) { + continue; + } + fillThreeBodyTables(); } } From cc4b7e537005762dd4e0f53992ef25b28191ddba Mon Sep 17 00:00:00 2001 From: creetz16 Date: Tue, 21 Jul 2026 17:05:27 +0200 Subject: [PATCH 6/7] (Hopefully) last fixes --- .../TableProducer/Nuspex/trackedHypertritonRecoTask.cxx | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx index e9a5fc56f65..72423b30add 100644 --- a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx @@ -700,9 +700,10 @@ struct TrackedHypertritonRecoTask { auto heTrackCov = getTrackParCov(heTrack); auto piTrackCov = getTrackParCov(piTrack); - if (twoBody.useKFParticle && !fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov)) { - return; - } else if (!fit2bodyWithDCAFitter(heTrackCov, piTrackCov)) { + const bool fitSucceeded = twoBody.useKFParticle + ? fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov) + : fit2bodyWithDCAFitter(heTrackCov, piTrackCov); + if (!fitSucceeded) { return; } @@ -931,7 +932,7 @@ struct TrackedHypertritonRecoTask { o2::base::Propagator::Instance()->propagateToDCABxByBz({builder3Body.decay3body.position[0], builder3Body.decay3body.position[1], builder3Body.decay3body.position[2]}, itsTrackParCov, 2.f, fitter2Body.getMatCorrType(), &dcaInfoItsTrack); builder3Body.decay3body.itsTrackDCAToSV[0] = dcaInfoItsTrack[0]; builder3Body.decay3body.itsTrackDCAToSV[1] = dcaInfoItsTrack[1]; - if (threeBody.useSelections && (builder3Body.decay3body.itsTrackDCAToSV[0] > threeBody.maxITSDCAxytrackToSV || builder3Body.decay3body.itsTrackDCAToSV[1] > threeBody.maxITSDCAztrackToSV)) { + if (threeBody.useSelections && (std::abs(builder3Body.decay3body.itsTrackDCAToSV[0]) > threeBody.maxITSDCAxytrackToSV || std::abs(builder3Body.decay3body.itsTrackDCAToSV[1]) > threeBody.maxITSDCAztrackToSV)) { continue; } From 179ddd2d6dcaa3427b14fac03464b23accade3f1 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Tue, 21 Jul 2026 15:06:08 +0000 Subject: [PATCH 7/7] Please consider the following formatting changes --- PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx index 72423b30add..bb15833d0e1 100644 --- a/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx +++ b/PWGLF/TableProducer/Nuspex/trackedHypertritonRecoTask.cxx @@ -701,8 +701,8 @@ struct TrackedHypertritonRecoTask { auto piTrackCov = getTrackParCov(piTrack); const bool fitSucceeded = twoBody.useKFParticle - ? fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov) - : fit2bodyWithDCAFitter(heTrackCov, piTrackCov); + ? fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov) + : fit2bodyWithDCAFitter(heTrackCov, piTrackCov); if (!fitSucceeded) { return; }