[PWGLF] Updates to trackedHypertritonRecoTask.cxx

PWGLF/DataModel/Vtx3BodyTables.h

@@ -35,7 +35,7 @@
 DECLARE_SOA_INDEX_COLUMN_FULL(TrackPi, trackPi, int, Tracks, "_pi"); //!
 DECLARE_SOA_INDEX_COLUMN_FULL(TrackDe, trackDe, int, Tracks, "_de"); //!
 DECLARE_SOA_INDEX_COLUMN(Collision, collision);                      //!
 DECLARE_SOA_INDEX_COLUMN(Decay3Body, decay3body);                    //!
 
 // General 3 body Vtx properties
 DECLARE_SOA_COLUMN(Mass, mass, float); //! candidate mass (with H3L or Anti-H3L mass hypothesis depending on deuteron charge)
@@ -64,15 +64,15 @@
 DECLARE_SOA_COLUMN(XTrackDe, xTrackDe, float);   //! track2 x at IU
 
 // DCAs to PV
 DECLARE_SOA_COLUMN(DCAXYTrackPrToPV, dcaXYtrackPrToPv, float);         //! DCAXY of proton to PV (computed with KFParticle)
 DECLARE_SOA_COLUMN(DCAXYTrackPiToPV, dcaXYtrackPiToPv, float);         //! DCAXY of pion to PV (computed with KFParticle)
 DECLARE_SOA_COLUMN(DCAXYTrackDeToPV, dcaXYtrackDeToPv, float);         //! DCAXY of deuteron to PV (computed with KFParticle)
 DECLARE_SOA_COLUMN(DCATrackPrToPV, dcaTrackPrToPv, float);             //! DCA of proton to PV (computed with KFParticle)
 DECLARE_SOA_COLUMN(DCATrackPiToPV, dcaTrackPiToPv, float);             //! DCA of pion to PV (computed with KFParticle)
 DECLARE_SOA_COLUMN(DCATrackDeToPV, dcaTrackDeToPv, float);             //! DCA of deuteron to PV (computed with KFParticle)
 DECLARE_SOA_COLUMN(DCAXYTrackPrToPVProp, dcaXYtrackPrToPvProp, float); //! DCAXY of proton to PV (propagated with O2 Propagator)
 DECLARE_SOA_COLUMN(DCAXYTrackPiToPVProp, dcaXYtrackPiToPvProp, float); //! DCAXY of pion to PV (propagated with O2 Propagator)
 DECLARE_SOA_COLUMN(DCAXYTrackDeToPVProp, dcaXYtrackDeToPvProp, float); //! DCAXY of deuteron to PV (propagated with O2 Propagator)
 DECLARE_SOA_COLUMN(DCATrackPrToPVProp, dcaTrackPrToPvProp, float);     //! DCA of proton to PV (propagated with O2 Propagator)
 DECLARE_SOA_COLUMN(DCATrackPiToPVProp, dcaTrackPiToPvProp, float);     //! DCA of pion to PV (propagated with O2 Propagator)
 DECLARE_SOA_COLUMN(DCATrackDeToPVProp, dcaTrackDeToPvProp, float);     //! DCA of deuteron to PV (propagated with O2 Propagator)
@@ -140,6 +140,10 @@
 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 @@
                   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<>,

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]) {

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<aod::Collisions, aod::EvSels, aod::CentFT0As, aod::CentFT0Cs, aod::CentFT0Ms, aod::EvTimeTOFFT0>;
@@ -94,12 +96,11 @@ enum ZorroTrigger : std::size_t {
 } // namespace
 
 struct TrackedHypertritonRecoTask {
-  o2::common::core::MetadataHelper metadataInfo{};
-
   Produces<aod::DataHypCands> dataHypCands;
   Produces<aod::MCHypCands> mcHypCands;
   Produces<aod::Vtx3BodyDatas> vtx3BodyDatas;
   Produces<aod::Vtx3BodyCovs> vtx3BodyCovs;
+  Produces<aod::Vtx3BodyTrackedInfo> vtx3BodyTrackedInfo;
   Produces<aod::McVtx3BodyDatas> mcVtx3BodyDatas;
 
   Service<o2::ccdb::BasicCCDBManager> ccdb{};
@@ -124,7 +125,9 @@ struct TrackedHypertritonRecoTask {
 
   struct : ConfigurableGroup {
     std::string prefix = "twoBody";
+    Configurable<bool> useKFParticle{"useKFParticle", false, "Use KFParticle to build the two-body candidate"};
     Configurable<bool> useSelections{"useSelections", false, "Apply the two-body candidate selections"};
+    Configurable<bool> kfSetTopologicalConstraint{"kfSetTopologicalConstraint", false, "Set topological vertex constraint in case of KFParticle reconstruction"};
     Configurable<float> maxEtaDaughters{"maxEtaDaughters", 1.e10f, "Maximum absolute daughter eta"};
     Configurable<float> minTPCNClsHe{"minTPCNClsHe", -1.f, "Minimum He TPC clusters"};
     Configurable<float> minTPCNClsPi{"minTPCNClsPi", -1.f, "Minimum pion TPC clusters"};
@@ -133,7 +136,7 @@ struct TrackedHypertritonRecoTask {
     Configurable<float> minTPCInnerParamHe{"minTPCInnerParamHe", -1.f, "Minimum He TPC rigidity"};
     Configurable<float> minPt{"minPt", -1.f, "Minimum candidate transverse momentum"};
     Configurable<float> massWindow{"massWindow", 1.e10f, "Half-width of the hypertriton mass window"};
-    Configurable<float> maxDcaDaughters{"maxDcaDaughters", 1.e10f, "Maximum DCA between daughters"};
+    Configurable<float> maxChi2{"maxChi2", 1.e10f, "KFParticle: Maximum SV chi2, DCA fitter: Maximum DCA between daughters"};
     Configurable<float> minCosPA{"minCosPA", -2.f, "Minimum cosine of the pointing angle"};
     Configurable<float> minDcaHeToPV{"minDcaHeToPV", -1.f, "Minimum absolute He DCA to PV"};
     Configurable<float> minDcaPiToPV{"minDcaPiToPV", -1.f, "Minimum absolute pion DCA to PV"};
@@ -179,6 +182,8 @@ struct TrackedHypertritonRecoTask {
     Configurable<float> maxCtau{"maxCtau", 100.f, "Maximum candidate c tau"};
     Configurable<float> minCosPA{"minCosPA", 0.9f, "Minimum candidate cosine of the pointing angle"};
     Configurable<float> maxChi2{"maxChi2", 100.f, "Maximum candidate chi2"};
+    Configurable<float> maxITSDCAxytrackToSV{"maxITSDCAxytrackToSV", 10.0, "Maximum distance of ITS matched track to SV in xy"};
+    Configurable<float> 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<int> recoCollisionForMC;
   std::vector<bool> survivedMCEventSelection;
 
+  struct v0Candidate {
+    // daughter properties
+    std::array<float, 3> momHelium{};
+    std::array<float, 3> momPion{};
+    std::array<float, 3> posHelium{};
+    std::array<float, 3> posPion{};
+    // vertex properties
+    float mass{};
+    float chi2{};
+    float cosPA{};
+    std::array<float, 3> decayVertex{};
+    std::array<float, 3> momentum{};
+  };
+
+  v0Candidate v0;
+
   struct TwoBodyMCInfo {
     float genPt = -1.f;
     float genPhi = -1.f;
@@ -536,52 +557,166 @@ struct TrackedHypertritonRecoTask {
     return (track.tpcSignal() - expected) / (expected * bbParamsHe[5]);
   }
 
-  template <typename TTrack, typename TCollision, typename TFillCandidate>
-  void buildTwoBody(TTrack const& heTrack, TTrack const& piTrack, TCollision const& collision, float trackedClSize, TFillCandidate const& fillCandidate)
+  template <typename TCollision, typename TTrack, typename TTrackParCov>
+  bool fit2BodyWithKF(TCollision const& collision,
+                      TTrack const& trackHelium,
+                      TTrack const& trackPion,
+                      TTrackParCov const& trackHeliumCov,
+                      TTrackParCov const& trackPionCov)
+  {
+    // initialise KF primary vertex
+    KFParticle kfpv(createKFPVertexFromCollision(collision));
+
+    // create KFParticle objects
+    KFParticle kfpHelium, kfpPion;
+    // helium
+    std::array<float, 3> xyz{};
+    std::array<float, 3> pxpypz{};
+    std::array<float, 6> xyzpxpypz{};
+    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<float, 21> cv{};
+    trackHeliumCov.getCovXYZPxPyPzGlo(cv);
+    KFParticle kfHelium;
+    kfHelium.Create(xyzpxpypz.data(), 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 false;
+    }
+
+    // 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{};
+    float massErr{};
+    KFV0.GetMass(mass, massErr);
+    v0.mass = mass;
+
+    // vertex chi2
+    v0.chi2 = KFV0.GetChi2() / KFV0.GetNDF();
+
+    return true;
+  }
+
+  template <typename TTrackParCov>
+  bool 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;
+      return false;
     }
     if (nCandidates == 0) {
-      return;
+      return false;
     }
 
-    std::array<float, 3> heMomentum{};
-    std::array<float, 3> 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<float, 3> 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());
+
+    return true;
+  }
+
+  template <typename TTrack, typename TCollision, typename TFillCandidate>
+  void buildTwoBody(TTrack const& heTrack, TTrack const& piTrack, TCollision const& collision, float trackedClSize, TFillCandidate const& fillCandidate)
+  {
     const std::array<float, 3> primaryVertex{collision.posX(), collision.posY(), collision.posZ()};
-    const std::array<float, 3> decayVertex{static_cast<float>(secondaryVertex[0]), static_cast<float>(secondaryVertex[1]), static_cast<float>(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);
+
+    const bool fitSucceeded = twoBody.useKFParticle
+                                ? fit2BodyWithKF(collision, heTrack, piTrack, heTrackCov, piTrackCov)
+                                : fit2bodyWithDCAFitter(heTrackCov, piTrackCov);
+    if (!fitSucceeded) {
+      return;
+    }
+
+    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<float, 2> 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 +740,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<int16_t>(heTrack.tpcNClsFindable()) - heTrack.tpcNClsFindableMinusPID(),
                   static_cast<int16_t>(piTrack.tpcNClsFindable()) - piTrack.tpcNClsFindableMinusPID(),
@@ -661,7 +796,8 @@ struct TrackedHypertritonRecoTask {
                   candidate.averageITSClSize[0], candidate.averageITSClSize[1], candidate.averageITSClSize[2],
                   static_cast<int>(candidate.tpcNCl[0]), static_cast<int>(candidate.tpcNCl[1]), static_cast<int>(candidate.tpcNCl[2]),
                   static_cast<uint32_t>(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]);
   }
 
   void fillThreeBodyMCTable(ThreeBodyMCInfo const& info)
@@ -776,17 +912,30 @@ struct TrackedHypertritonRecoTask {
       if (decay3Body.collisionId() < 0 || !goodCollision[decay3Body.collisionId()] || (skimmedProcessing && !zorroDecision[decay3Body.collisionId()][kTracked3Body])) {
         continue;
       }
+
       const auto collision = decay3Body.collision_as<Collisions>();
       const auto trackPositive = decay3Body.track0_as<Tracks>();
       const auto trackNegative = decay3Body.track1_as<Tracks>();
       const auto trackDeuteron = decay3Body.track2_as<Tracks>();
       const auto trackProton = trackDeuteron.sign() > 0 ? trackPositive : trackNegative;
       const auto trackPion = trackDeuteron.sign() > 0 ? trackNegative : trackPositive;
+
       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<Tracks>();
+        auto itsTrackParCov = getTrackParCov(itsTrack);
+        std::array<float, 2> 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 && (std::abs(builder3Body.decay3body.itsTrackDCAToSV[0]) > threeBody.maxITSDCAxytrackToSV || std::abs(builder3Body.decay3body.itsTrackDCAToSV[1]) > threeBody.maxITSDCAztrackToSV)) {
+          continue;
+        }
+
         fillThreeBodyTables();
       }
     }
@@ -987,7 +1136,6 @@ struct TrackedHypertritonRecoTask {
 
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
-  auto metadataInfo = o2::common::core::MetadataHelper{};
   metadataInfo.initMetadata(cfgc);
-  return WorkflowSpec{adaptAnalysisTask<TrackedHypertritonRecoTask>(cfgc, std::move(metadataInfo))};
+  return WorkflowSpec{adaptAnalysisTask<TrackedHypertritonRecoTask>(cfgc)};
 }