CaloFuture/CaloFuturePIDs/src/SelectiveBremMatchAlg.cpp

@@ -168,14 +168,20 @@ namespace LHCb::Calo {
   // ============================================================================
 
   SelectiveBremMatchAlg::SelectiveBremMatchAlg( const std::string& name, ISvcLocator* pSvc )
-      : MultiTransformer( name, pSvc,
-                          // Inputs
-                          {KeyValue( "Detector", {CaloFutureAlgUtils::DeCaloFutureLocation( "Ecal" )} ),
-                           KeyValue( "InputHypos", {CaloFutureAlgUtils::CaloFutureHypoLocation( "Photons" )} ),
-                           KeyValue( "InputDigits", {CaloDigitLocation::Ecal} ), KeyValue( "TracksInCalo", "" ),
-                           KeyValue( "cellSizeCovariances", {"AlgorithmSpecific-" + name + "-cellsizecovariances"} )},
-                          // Outputs
-                          {KeyValue( "OutputMatchTable", {} ), KeyValue( "OutputEnergyTable", {} )} ) {}
+      : MultiTransformer(
+            name, pSvc,
+            // Inputs
+            {KeyValue( "Detector", {CaloFutureAlgUtils::DeCaloFutureLocation( "Ecal" )} ),
+             KeyValue( "InputHypos", {CaloFutureAlgUtils::CaloFutureHypoLocation( "Photons" )} ),
+             KeyValue( "InputDigits", {CaloDigitLocation::Ecal} ), KeyValue( "TracksInCalo", "" ),
+#ifdef USE_DD4HEP
+             KeyValue( "cellSizeCovariances", {"/world:AlgorithmSpecific-" + name + "-cellsizecovariances"} )},
+#else
+             KeyValue( "cellSizeCovariances", {"AlgorithmSpecific-" + name + "-cellsizecovariances"} )},
+#endif
+            // Outputs
+            {KeyValue( "OutputMatchTable", {} ), KeyValue( "OutputEnergyTable", {} )} ) {
+  }
 
   // ============================================================================
   //   Initialization of algorithm / tool

CaloFuture/CaloFuturePIDs/src/SelectiveElectronMatchAlg.cpp

@@ -176,10 +176,15 @@ namespace LHCb::Calo {
                      {KeyValue( "Detector", {CaloFutureAlgUtils::DeCaloFutureLocation( "Ecal" )} ),
                       KeyValue( "InputHypos", {LHCb::CaloFutureAlgUtils::CaloFutureHypoLocation( "Electrons" )} ),
                       KeyValue( "InputTracks2Clusters", "" ),
+#ifdef USE_DD4HEP
+                      KeyValue( "XCorrections", {"/world:AlgorithmSpecific-" + name + "-xcorrections"} ),
+#else
                       KeyValue( "XCorrections", {"AlgorithmSpecific-" + name + "-xcorrections"} ),
+#endif
                       KeyValue( "Magnet", LHCb::Det::Magnet::det_path )},
                      // Outputs
-                     {KeyValue( "Output", "" )} ) {}
+                     {KeyValue( "Output", "" )} ) {
+  }
 
   // ============================================================================
   //   Initialization of algorithm / tool

CaloFuture/CaloFuturePIDs/src/SelectiveTrackMatchAlg.cpp

@@ -104,9 +104,14 @@ namespace LHCb::Calo {
                      {KeyValue( "Detector", {CaloFutureAlgUtils::DeCaloFutureLocation( "Ecal" )} ),
                       KeyValue( "InputClusters", {CaloFutureAlgUtils::CaloFutureClusterLocation( "Ecal" )} ),
                       KeyValue( "InputTracksInCalo", "" ),
+#ifdef USE_DD4HEP
+                      KeyValue( "cellSizeCovariances", {"/world:AlgorithmSpecific-" + name + "-cellsizecovariances"} )},
+#else
                       KeyValue( "cellSizeCovariances", {"AlgorithmSpecific-" + name + "-cellsizecovariances"} )},
+#endif
                      // Outputs
-                     {KeyValue( "Output", {CaloFutureAlgUtils::CaloFutureIdLocation( "ClusterMatch" )} )} ) {}
+                     {KeyValue( "Output", {CaloFutureAlgUtils::CaloFutureIdLocation( "ClusterMatch" )} )} ) {
+  }
 
   // ============================================================================
   //   Initialization of algorithm / tool

Pr/PrAlgorithms/src/PrForwardTracking.cpp

@@ -1777,20 +1777,15 @@ namespace LHCb::Pr::Forward {
      * Paths are figured out by the scheduler.
      ********************************************************************************/
     PrForwardTracking( std::string const& name, ISvcLocator* pSvcLocator )
-        : base_class_t(
-              name, pSvcLocator,
-              {typename base_class_t::KeyValue{"SciFiHits", ""}, typename base_class_t::KeyValue{"InputTracks", ""},
-#ifdef USE_DD4HEP
-               typename base_class_t::KeyValue{"FTZoneCache", "/world:AlgorithmSpecific-" + name + "-FTZoneCache"},
-#else
-               typename base_class_t::KeyValue{"FTZoneCache", "AlgorithmSpecific-" + name + "-FTZoneCache"},
-#endif
-               typename base_class_t::KeyValue{"AddUTHitsToolName", "PrAddUTHitsTool"},
-               typename base_class_t::KeyValue{"Magnet", LHCb::Det::Magnet::det_path}},
-              typename base_class_t::KeyValue{"OutputTracks", ""} )
+        : base_class_t( name, pSvcLocator,
+                        {typename base_class_t::KeyValue{"SciFiHits", ""},
+                         typename base_class_t::KeyValue{"InputTracks", ""},
+                         typename base_class_t::KeyValue{"FTZoneCache", FTZoneCache::Location + name},
+                         typename base_class_t::KeyValue{"AddUTHitsToolName", "PrAddUTHitsTool"},
+                         typename base_class_t::KeyValue{"Magnet", LHCb::Det::Magnet::det_path}},
+                        typename base_class_t::KeyValue{"OutputTracks", ""} )
         , m_NN{NNVars}
-        , m_NNVeloUT{NNVarsVeloUT} {
-    }
+        , m_NNVeloUT{NNVarsVeloUT} {}
 
     /********************************************************************************
      * Initialisation, set some member variables and cache

Pr/PrAlgorithms/src/PrHybridSeeding.cpp

@@ -841,14 +841,9 @@ namespace LHCb::Pr {
   HybridSeeding::HybridSeeding( const std::string& name, ISvcLocator* pSvcLocator )
       : Transformer( name, pSvcLocator,
                      {KeyValue{"FTHitsLocation", PrFTInfo::SciFiHitsLocation},
-#ifdef USE_DD4HEP
-                      KeyValue{"ZoneCache", "/world:AlgorithmSpecific-" + name + "-ZoneCache"},
-#else
-                      KeyValue{"ZoneCache", "AlgorithmSpecific-" + name + "-ZoneCache"},
-#endif
+                      KeyValue{"ZoneCache", FTZoneCache::Location + name},
                       KeyValue{"Magnet", LHCb::Det::Magnet::det_path}},
-                     KeyValue{"OutputName", LHCb::TrackLocation::Seed} ) {
-  }
+                     KeyValue{"OutputName", LHCb::TrackLocation::Seed} ) {}
 
   //=============================================================================
   // Initialization

Pr/PrAlgorithms/src/PrStoreFTHit.cpp

@@ -45,15 +45,8 @@ public:
   PrStoreFTHit( const std::string& name, ISvcLocator* pSvcLocator )
       : Transformer( name, pSvcLocator,
                      {KeyValue{"InputLocation", LHCb::FTLiteClusterLocation::Default},
-                      KeyValue{"FTMatsCache",
-#ifdef USE_DD4HEP
-                               "/world:AlgorithmSpecific-" + name + "FTMatsCache"
-#else
-                               "AlgorithmSpecific-" + name + "FTMatsCache"
-#endif
-                      }},
-                     KeyValue{"FTHitsLocation", PrFTInfo::FTHitsLocation} ) {
-  }
+                      KeyValue{"FTMatsCache", FTMatsCache::Location + name}},
+                     KeyValue{"FTHitsLocation", PrFTInfo::FTHitsLocation} ) {}
 
   StatusCode initialize() override {
     return Transformer::initialize().andThen( [&] {

Pr/PrAlgorithms/src/PrStoreSciFiHits.cpp

@@ -19,6 +19,7 @@
 #include "LHCbAlgs/Transformer.h"
 #include "LHCbMath/bit_cast.h"
 #include "PrKernel/FTMatsCache.h"
+#include "PrKernel/PrFTZoneHandler.h"
 
 #include <array>
 #include <limits>
@@ -49,18 +50,9 @@ namespace LHCb::Pr::FT {
   public:
     StoreHits( const std::string& name, ISvcLocator* pSvcLocator )
         : Transformer( name, pSvcLocator,
-                       {KeyValue{"HitsLocation", LHCb::FTLiteClusterLocation::Default},
-#ifdef USE_DD4HEP
-                        KeyValue {
-                          "FTMatsCache",
-                          "/world:AlgorithmSpecific-" + name + "-FTMatsCache"
-                        }
-#else
-                        KeyValue{"FTMatsCache", "AlgorithmSpecific-" + name + "-FTMatsCache"}
-#endif
-                       },
-                       KeyValue{"Output", PrFTInfo::SciFiHitsLocation} ) {
-    }
+                       {KeyValue{"HitsLocation", FTLiteClusterLocation::Default},
+                        KeyValue{"FTMatsCache", FTZoneCache::MatLocation + name}},
+                       KeyValue{"Output", PrFTInfo::SciFiHitsLocation} ) {}
 
     StatusCode initialize() override {
       return Transformer::initialize().andThen( [&] {

Pr/PrFitParams/CMakeLists.txt

@@ -13,14 +13,10 @@ Pr/PrFitParams
 --------------
 #]=======================================================================]
 
-gaudi_add_library(PrFitParamsLib
-    SOURCES
-        src/PrFitTool.cpp
+gaudi_add_header_only_library(PrFitParamsLib
     LINK
-        PUBLIC
-            Gaudi::GaudiAlgLib
-            Gaudi::GaudiKernel
-            ROOT::MathCore
+        Gaudi::GaudiKernel
+        ROOT::MathCore
 )
 
 gaudi_add_module(PrFitParams
@@ -30,6 +26,8 @@ gaudi_add_module(PrFitParams
         src/PrFitMatchParams.cpp
         src/PrFitParameters.cpp
         src/PrFitSeedParams.cpp
+        src/PrParameterisationData.cpp
+        src/PrFitTool.cpp
     LINK
         Gaudi::GaudiAlgLib
         Gaudi::GaudiKernel
@@ -38,4 +36,6 @@ gaudi_add_module(PrFitParams
         LHCb::MCEvent
         LHCb::TrackEvent
         PrFitParamsLib
+        PrKernel
+        TrackInterfacesLib
 )

Pr/PrFitParams/src/PrFitFwdParams.cpp

@@ -18,7 +18,7 @@
 #include "GaudiKernel/Vector3DTypes.h"
 #include "Linker/LinkedTo.h"
 #include "PrFitParameters.h"
-#include "PrFitParams/PrFitTool.h"
+#include "PrFitParams/IPrFitTool.h"
 #include <string>
 
 //-----------------------------------------------------------------------------

Pr/PrFitParams/src/PrFitKsParams.cpp

@@ -15,7 +15,7 @@
 #include "GaudiKernel/Point3DTypes.h"
 #include "GaudiKernel/SystemOfUnits.h"
 #include "PrFitParameters.h"
-#include "PrFitParams/PrFitTool.h"
+#include "PrFitParams/IPrFitTool.h"
 
 //-----------------------------------------------------------------------------
 // Implementation file for class : PrFitKsParams

Pr/PrFitParams/src/PrFitMatchParams.cpp

@@ -22,7 +22,7 @@
 #include "Linker/LinkedFrom.h"
 #include "Linker/LinkedTo.h"
 #include "PrFitParameters.h"
-#include "PrFitParams/PrFitTool.h"
+#include "PrFitParams/IPrFitTool.h"
 #include <vector>
 
 //-----------------------------------------------------------------------------

Pr/PrFitParams/src/PrFitSeedParams.cpp

@@ -15,7 +15,7 @@
 #include "Event/StateParameters.h"
 #include "GaudiAlg/GaudiTupleAlg.h"
 #include "PrFitParameters.h"
-#include "PrFitParams/PrFitTool.h"
+#include "PrFitParams/IPrFitTool.h"
 
 //-----------------------------------------------------------------------------
 // Implementation file for class : PrFitSeedParams

Pr/PrFitParams/src/PrFitTool.cpp

@@ -8,18 +8,37 @@
 * granted to it by virtue of its status as an Intergovernmental Organization  *
 * or submit itself to any jurisdiction.                                       *
 \*****************************************************************************/
-// Include files
+#include "GaudiAlg/GaudiTool.h"
+#include "GaudiKernel/Point3DTypes.h"
+#include "PrFitParams/IPrFitTool.h"
+#include "PrFitParams/LinParFit.h"
 
-// local
-#include "PrFitParams/PrFitTool.h"
+/** @class PrFitTool PrFitTool.h
+ *
+ *
+ *  @author Olivier Callot
+ *  @date   2006-12-08
+ */
+class PrFitTool final : public extends<GaudiTool, IPrFitTool> {
+public:
+  /// Standard constructor
+  using extends::extends;
 
-//-----------------------------------------------------------------------------
-// Implementation file for class : PrFitTool
-//
-// 2006-12-08 : Olivier Callot
-//-----------------------------------------------------------------------------
+  std::optional<std::tuple<double, double>> fitLine( const std::vector<Gaudi::XYZPoint>& hit, XY mode,
+                                                     double z0 ) const override;
+
+  std::optional<std::tuple<double, double, double>> fitParabola( const std::vector<Gaudi::XYZPoint>& hit, XY mode,
+                                                                 double z0 ) const override;
+
+  std::optional<std::tuple<double, double, double, double>> fitCubic( const std::vector<Gaudi::XYZPoint>& hit, XY mode,
+                                                                      double z0 ) const override;
+
+private:
+  mutable LinParFit<double> m_fit2{2};
+  mutable LinParFit<double> m_fit3{3};
+  mutable LinParFit<double> m_fit4{4};
+};
 
-// Declaration of the Tool Factory
 DECLARE_COMPONENT( PrFitTool )
 
 //=========================================================================

Pr/PrFitParams/src/PrParameterisationData.cpp

+/*****************************************************************************\
+* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration           *
+*                                                                             *
+* This software is distributed under the terms of the GNU General Public      *
+* Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
+*                                                                             *
+* In applying this licence, 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 <algorithm>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "Magnet/DeMagnet.h"
+
+#include "DetDesc/DetectorElement.h"
+#include "DetDesc/GenericConditionAccessorHolder.h"
+#include "Event/MCHit.h"
+#include "Event/MCParticle.h"
+#include "Event/StateVector.h"
+#include "FTDAQ/FTInfo.h"
+#include "FTDet/DeFTDetector.h"
+#include "LHCbAlgs/Consumer.h"
+
+#include "PrFitParams/IPrFitTool.h"
+#include "PrKernel/IPrDebugTrackingTool.h"
+#include "PrKernel/PrFTZoneHandler.h"
+#include "TrackInterfaces/ITrackExtrapolator.h"
+
+namespace {
+  using FTZoneCache::ZoneCache;
+}
+
+class PrParameterisationData
+    : public LHCb::Algorithm::Consumer<void( const LHCb::MCParticles&, const LHCb::MCHits&, const LHCb::MCHits&,
+                                             const DetectorElement&, const ZoneCache&, const DeMagnet& ),
+                                       LHCb::DetDesc::usesConditions<DetectorElement, ZoneCache, DeMagnet>> {
+public:
+  PrParameterisationData( const std::string& name, ISvcLocator* pSvcLocator )
+      : Consumer( name, pSvcLocator,
+                  {KeyValue{"MCParticles", ""}, KeyValue{"MCVPHits", ""}, KeyValue{"MCFTHits", ""},
+                   KeyValue{"StandardGeometryTop", LHCb::standard_geometry_top},
+#ifdef USE_DD4HEP
+                   KeyValue{"FTZoneCache", "/world:AlgorithmSpecific-" + name + "-FTZoneCache"},
+#else
+                   KeyValue{"FTZoneCache", "AlgorithmSpecific-" + name + "-FTZoneCache"},
+#endif
+                   KeyValue{"Magnet", LHCb::Det::Magnet::det_path}} ){};
+
+  using base_class_t =
+      LHCb::Algorithm::Consumer<void( const LHCb::MCParticles&, const LHCb::MCHits&, const LHCb::MCHits&,
+                                      const DetectorElement&, const ZoneCache&, const DeMagnet& ),
+                                LHCb::DetDesc::usesConditions<DetectorElement, ZoneCache, DeMagnet>>;
+
+  StatusCode initialize() override {
+    auto sc = base_class_t::initialize();
+    if ( sc.isFailure() ) return sc;
+    addConditionDerivation<ZoneCache( const DeFT& )>( {DeFTDetectorLocation::Default},
+                                                      this->template inputLocation<ZoneCache>() );
+    return sc;
+  }
+
+  void operator()( const LHCb::MCParticles&, const LHCb::MCHits&, const LHCb::MCHits&, const DetectorElement&,
+                   const ZoneCache&, const DeMagnet& ) const override;
+
+private:
+  Gaudi::Property<double> m_zEndVelo{this, "zEndVelo", 770. * Gaudi::Units::mm};
+  Gaudi::Property<double> m_zRef{this, "zRef", 8520. * Gaudi::Units::mm};
+  Gaudi::Property<double> m_zOutOfMagField{this, "zOutOfMagField", 10. * Gaudi::Units::m};
+
+  ToolHandle<IPrDebugTrackingTool> m_debugTool{this, "DebugTool", "PrMCDebugReconstructibleLong"};
+  ToolHandle<IPrFitTool>           m_fitTool{this, "FitTool", "PrFitTool"};
+  ToolHandle<ITrackExtrapolator>   m_extrap{this, "Extrapolator", "TrackRungeKuttaExtrapolator"};
+};
+
+DECLARE_COMPONENT( PrParameterisationData )
+
+void PrParameterisationData::operator()( const LHCb::MCParticles& mc_particles, const LHCb::MCHits& mc_vphits,
+                                         const LHCb::MCHits& mc_fthits, const DetectorElement& lhcb,
+                                         const ZoneCache& ft_cache, const DeMagnet& magnet ) const {
+
+  for ( auto mcp : mc_particles ) {
+    const auto mcp_key = mcp->index();
+    // check if long reconstructible (3 velo hits + one x and one uv hit in every SciFi station)
+    if ( !m_debugTool->check( mcp_key ) ) continue;
+
+    // now copy all MC velo hits that belong to this MC particle (MCHit and positions)
+    std::vector<LHCb::MCHit*>    velo_hits{};
+    std::vector<Gaudi::XYZPoint> velo_hit_positions{};
+    velo_hits.reserve( 50 );
+    velo_hit_positions.reserve( 50 );
+    std::copy_if( mc_vphits.begin(), mc_vphits.end(), std::back_inserter( velo_hits ),
+                  [&mcp]( auto hit ) { return mcp == hit->mcParticle(); } );
+    std::transform( velo_hits.begin(), velo_hits.end(), std::back_inserter( velo_hit_positions ),
+                    []( auto hit ) { return hit->midPoint(); } );
+
+    // now copy all MC scifi hits that belong to this MC particle (MCHit and positions)
+    std::vector<LHCb::MCHit*> scifi_hits{};
+    scifi_hits.reserve( 16 );
+    std::vector<Gaudi::XYZPoint> scifi_hit_positions{};
+    scifi_hit_positions.reserve( 16 );
+    std::copy_if( mc_fthits.begin(), mc_fthits.end(), std::back_inserter( scifi_hits ),
+                  [&mcp]( auto hit ) { return mcp == hit->mcParticle(); } );
+    std::transform( scifi_hits.begin(), scifi_hits.end(), std::back_inserter( scifi_hit_positions ),
+                    []( auto hit ) { return hit->midPoint(); } );
+
+    // to not depend on the velo tracking, the velo hits are simply fitted with a straight line without errors
+    const auto velo_x_result = m_fitTool->fitLine( velo_hit_positions, IPrFitTool::XY::X, m_zEndVelo );
+    const auto velo_y_result = m_fitTool->fitLine( velo_hit_positions, IPrFitTool::XY::Y, m_zEndVelo );
+    assert( velo_x_result && velo_y_result );
+    const auto [x0, tx] = velo_x_result.value();
+    const auto [y0, ty] = velo_y_result.value();
+
+    // A track is defined as x = AX + BX*dz + CX*dz*dz + DX*dz*dz*dz
+    //                       y = AY + BY*dz + CY*dz*dz
+    const auto trFitX = m_fitTool->fitCubic( scifi_hit_positions, IPrFitTool::XY::X, m_zRef );
+    assert( trFitX );
+    const auto [AX, BX, CX, DX] = trFitX.value();
+    const auto trFitY           = m_fitTool->fitParabola( scifi_hit_positions, IPrFitTool::XY::Y, m_zRef );
+    assert( trFitY );
+    const auto [AY, BY, CY] = trFitY.value();
+
+    const auto [chi2_x, chi2_y, chi2_comb] = [&, AX = AX, BX = BX, CX = CX, DX = DX, AY = AY, BY = BY, CY = CY,
+                                              x_err = 0.1 * Gaudi::Units::mm, y_err = 1. * Gaudi::Units::mm] {
+      auto chi2_x{0.};
+      auto chi2_y{0.};
+      auto chi2_comb{0.};
+      for ( auto pos : scifi_hit_positions ) {
+        const auto dz = pos.z() - m_zRef;
+        const auto dx = pos.x() - ( AX + dz * ( BX + dz * ( CX + dz * DX ) ) );
+        const auto dy = pos.y() - ( AY + dz * ( BY + dz * CY ) );
+        chi2_x += dx * dx / ( x_err * x_err );
+        chi2_y += dy * dy / ( y_err * y_err );
+        chi2_comb += dx * dx / ( x_err * x_err ) + dy * dy / ( y_err * y_err );
+      }
+      return std::tuple{chi2_x, chi2_y, chi2_comb};
+    }();
+    const int ndof_x = scifi_hit_positions.size() - 4;
+    const int ndof_y = scifi_hit_positions.size() - 3;
+
+    // let's get some info about the particle we are dealing with
+    const auto momentum            = mcp->p();
+    const auto transverse_momentum = mcp->pt();
+    const auto qop                 = ( mcp->particleID().threeCharge() / 3 ) / momentum;
+    const auto pid                 = std::abs( mcp->particleID().pid() );
+
+    // propagate velo state to reference plane
+    auto track_state = LHCb::StateVector{{x0, y0, tx, ty, qop}, m_zEndVelo};
+    if ( m_extrap->propagate( track_state, m_zRef, *lhcb.geometry() ).isFailure() ) { continue; }
+    // fix the state values at the reference plane
+    const auto x_ref  = track_state.x();
+    const auto y_ref  = track_state.y();
+    const auto z_ref  = m_zRef;
+    const auto tx_ref = track_state.tx();
+    const auto ty_ref = track_state.ty();
+    // propagate to behind SciFi stations outside of magnetic field
+    if ( m_extrap->propagate( track_state, m_zOutOfMagField, *lhcb.geometry() ).isFailure() ) { continue; }
+    const auto x_out      = track_state.x();
+    const auto y_out      = track_state.y();
+    const auto z_out      = m_zOutOfMagField;
+    const auto tx_out     = track_state.tx();
+    const auto ty_out     = track_state.ty();
+    const auto z_mag_x    = ( x_out - x0 - tx_out * m_zOutOfMagField + tx * m_zEndVelo ) / ( tx - tx_out );
+    const auto z_mag_y    = ( y_out - y0 - ty_out * m_zOutOfMagField + ty * m_zEndVelo ) / ( ty - ty_out );
+    const auto dSlope_out = tx_out - tx;
+    // now prepare stuff for tupling
+    std::vector<double> scifi_hit_x_positions{};
+    scifi_hit_x_positions.reserve( 16 );
+    std::vector<double> scifi_hit_y_positions{};
+    scifi_hit_y_positions.reserve( 16 );
+    std::vector<double> scifi_hit_z_positions{};
+    scifi_hit_z_positions.reserve( 16 );
+    std::transform( scifi_hit_positions.begin(), scifi_hit_positions.end(), std::back_inserter( scifi_hit_x_positions ),
+                    []( auto pos ) { return pos.x(); } );
+    std::transform( scifi_hit_positions.begin(), scifi_hit_positions.end(), std::back_inserter( scifi_hit_y_positions ),
+                    []( auto pos ) { return pos.y(); } );
+    std::transform( scifi_hit_positions.begin(), scifi_hit_positions.end(), std::back_inserter( scifi_hit_z_positions ),
+                    []( auto pos ) { return pos.z(); } );
+    const auto                                     magScaleFactor = magnet.signedRelativeCurrent();
+    std::vector<IPrDebugTrackingTool::VariableDef> variables{{"x", x0},
+                                                             {"y", y0},
+                                                             {"z", m_zEndVelo},
+                                                             {"tx", tx},
+                                                             {"ty", ty},
+                                                             {"p", momentum},
+                                                             {"pt", transverse_momentum},
+                                                             {"qop", qop},
+                                                             {"x_ref", x_ref},
+                                                             {"y_ref", y_ref},
+                                                             {"z_ref", z_ref},
+                                                             {"tx_ref", tx_ref},
+                                                             {"ty_ref", ty_ref},
+                                                             {"x_out", x_out},
+                                                             {"y_out", y_out},
+                                                             {"z_out", z_out},
+                                                             {"tx_out", tx_out},
+                                                             {"ty_out", ty_out},
+                                                             {"z_mag_x", z_mag_x},
+                                                             {"z_mag_y", z_mag_y},
+                                                             {"dSlope_out", dSlope_out},
+                                                             {"AX", AX},
+                                                             {"BX", BX},
+                                                             {"CX", CX},
+                                                             {"DX", DX},
+                                                             {"AY", AY},
+                                                             {"BY", BY},
+                                                             {"CY", CY},
+                                                             {"chi2_x", chi2_x},
+                                                             {"chi2_y", chi2_y},
+                                                             {"chi2_comb", chi2_comb},
+                                                             {"ndof_x", ndof_x},
+                                                             {"ndof_y", ndof_y},
+                                                             {"pid", pid},
+                                                             {"scifi_hit_x", scifi_hit_x_positions},
+                                                             {"scifi_hit_y", scifi_hit_y_positions},
+                                                             {"scifi_hit_z", scifi_hit_z_positions},
+                                                             {"signed_rel_current", magScaleFactor}};
+
+    // propagate to each scifi layer
+    std::array<std::pair<std::string, float>, 5 * LHCb::Pr::FT::Info::NFTLayers> layer_states;
+    if ( [&] {
+           // the zone z positions are taken according to the half the track passes through
+           const auto upper_half_track = y_ref > 0;
+           for ( auto iLayer{0}; iLayer < LHCb::Pr::FT::Info::NFTLayers; ++iLayer ) {
+             const auto iZone = 2 * iLayer + upper_half_track;
+             const auto zZone = ft_cache.zoneZPos[iZone];
+             if ( m_extrap->propagate( track_state, zZone, *lhcb.geometry() ).isFailure() ) { return true; }
+             layer_states[iLayer * 5]     = {"x_l" + std::to_string( iLayer ), track_state.x()};
+             layer_states[iLayer * 5 + 1] = {"y_l" + std::to_string( iLayer ), track_state.y()};
+             layer_states[iLayer * 5 + 2] = {"z_l" + std::to_string( iLayer ), track_state.z()};
+             layer_states[iLayer * 5 + 3] = {"tx_l" + std::to_string( iLayer ), track_state.tx()};
+             layer_states[iLayer * 5 + 4] = {"ty_l" + std::to_string( iLayer ), track_state.ty()};
+           }
+           return false;
+         }() ) {
+      continue;
+    }
+    variables.insert( variables.end(), layer_states.begin(), layer_states.end() );
+
+    m_debugTool->storeData( variables );
+  }
+}

Pr/PrKernel/dict/PrKernelDict.h

@@ -12,6 +12,7 @@
 #define DICT_PRKERNELDICT_H 1
 
 #include "PrKernel/IPrDebugTool.h"
+#include "PrKernel/IPrDebugTrackingTool.h"
 #include "PrKernel/IPrDebugUTTool.h"
 #include "PrKernel/IPrUTCounter.h"
 #include "PrKernel/IPrUTMagnetTool.h"

Pr/PrKernel/dict/PrKernelDict.xml

@@ -13,4 +13,5 @@
   <class name = "IPrDebugUTTool"  />
   <class name = "IPrUTCounter"    />
   <class name = "IPrUTMagnetTool" />
+  <class name = "IPrDebugTrackingTool" />
 </lcgdict>

Pr/PrKernel/include/PrKernel/FTMatsCache.h

@@ -16,6 +16,8 @@
 
 namespace FTMatsCache {
 
+  const std::string Location = "AlgorithmSpecific-FTMatsCache";
+
   struct MatsCache {
     /**
      * partial SoA cache for mats, reserve enough (here 4096 which is more than enough)

Pr/PrKernel/include/PrKernel/IPrDebugTrackingTool.h

@@ -23,7 +23,9 @@ struct IPrDebugTrackingTool : extend_interfaces<IAlgTool> {
 
   DeclareInterfaceID( IPrDebugTrackingTool, 1, 0 );
 
-  using VariableDef = std::pair<std::string_view, std::variant<int, float>>;
+  using VariableDef =
+      std::pair<std::string_view,
+                std::variant<int, float, double, std::vector<int>, std::vector<float>, std::vector<double>>>;
 
   virtual int check( int = -1, int = -1, const std::vector<int>& = {} ) const = 0;
 

Pr/PrFitParams/include/PrFitParams/PrFitTool.h → Pr/PrKernel/include/PrKernel/PrDebugTrackingToolBase.h

 /*****************************************************************************\
-* (c) Copyright 2000-2018 CERN for the benefit of the LHCb Collaboration      *
+* (c) Copyright 2022 CERN for the benefit of the LHCb Collaboration           *
 *                                                                             *
 * This software is distributed under the terms of the GNU General Public      *
 * Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
@@ -8,42 +8,46 @@
 * granted to it by virtue of its status as an Intergovernmental Organization  *
 * or submit itself to any jurisdiction.                                       *
 \*****************************************************************************/
-#ifndef PRFITTOOL_H
-#define PRFITTOOL_H 1
 
-// Include files
-// from Gaudi
-#include "GaudiAlg/GaudiTool.h"
+#pragma once
 
-#include "GaudiKernel/Point3DTypes.h"
+#include "PrKernel/IPrDebugTrackingTool.h"
 
-#include "PrFitParams/IPrFitTool.h"
-#include "PrFitParams/LinParFit.h"
+#include "GaudiAlg/GaudiTupleTool.h"
 
-/** @class PrFitTool PrFitTool.h
- *
- *
- *  @author Olivier Callot
- *  @date   2006-12-08
- */
+struct PrDebugTrackingToolBase : public extends<GaudiTupleTool, IPrDebugTrackingTool> {
 
-class PrFitTool final : public extends<GaudiTool, IPrFitTool> {
-public:
-  /// Standard constructor
+  // inherit standard constructors
   using extends::extends;
 
-  std::optional<std::tuple<double, double>> fitLine( const std::vector<Gaudi::XYZPoint>& hit, XY mode,
-                                                     double z0 ) const override;
-
-  std::optional<std::tuple<double, double, double>> fitParabola( const std::vector<Gaudi::XYZPoint>& hit, XY mode,
-                                                                 double z0 ) const override;
-
-  std::optional<std::tuple<double, double, double, double>> fitCubic( const std::vector<Gaudi::XYZPoint>& hit, XY mode,
-                                                                      double z0 ) const override;
-
-private:
-  mutable LinParFit<double> m_fit2{2};
-  mutable LinParFit<double> m_fit3{3};
-  mutable LinParFit<double> m_fit4{4};
+  /**
+   * @brief This is the default implementation for storing data in the tool interface.
+   *
+   * @param vars_and_values
+   * @param tuple_name
+   *
+   * @note Supports tupling of int, float, std::vector<int>, std::vector<float>. The vectors
+   * have an arbitrary size limit of 1024 entries.
+   */
+
+  virtual void storeData( LHCb::span<const VariableDef> vars_and_values, std::string_view tuple_name ) const override {
+
+    Tuple tuple = nTuple( std::string{tuple_name} );
+    for ( auto [name, value] : vars_and_values ) {
+      if ( std::holds_alternative<int>( value ) ) {
+        tuple->column( name, std::get<int>( value ) ).ignore();
+      } else if ( std::holds_alternative<float>( value ) ) {
+        tuple->column( name, std::get<float>( value ) ).ignore();
+      } else if ( std::holds_alternative<double>( value ) ) {
+        tuple->column( name, std::get<double>( value ) ).ignore();
+      } else if ( std::holds_alternative<std::vector<int>>( value ) ) {
+        tuple->farray( name, std::get<std::vector<int>>( value ), std::string{name} + "_length", 1024 ).ignore();
+      } else if ( std::holds_alternative<std::vector<float>>( value ) ) {
+        tuple->farray( name, std::get<std::vector<float>>( value ), std::string{name} + "_length", 1024 ).ignore();
+      } else {
+        tuple->farray( name, std::get<std::vector<double>>( value ), std::string{name} + "_length", 1024 ).ignore();
+      }
+    }
+    tuple->write().ignore();
+  }
 };
-#endif // PRFITTOOL_H

Pr/PrKernel/include/PrKernel/PrFTZoneHandler.h

@@ -20,6 +20,9 @@
 
 namespace FTZoneCache {
 
+  const std::string Location    = "AlgorithmSpecific-FTZoneCache";
+  const std::string MatLocation = "AlgorithmSpecific-FTMatsCache";
+
   /** @class PrFTZoneHandler PrFTZoneHandler.h
    * Handlers of zones, the object is stored in the detector event store as a condition
    * and each algorithms reads the object from there without calling the HitManagers (tools)