diff --git a/Control/CalypsoExample/TrackerDataAccessExample/python/TrackerDataAccessExampleConfig.py b/Control/CalypsoExample/TrackerDataAccessExample/python/TrackerDataAccessExampleConfig.py
index 0a2d083a8d0ca8a201bf9b34e4e8947289b57666..066f8560b4df98fae490fc79a876c21ae1332313 100755
--- a/Control/CalypsoExample/TrackerDataAccessExample/python/TrackerDataAccessExampleConfig.py
+++ b/Control/CalypsoExample/TrackerDataAccessExample/python/TrackerDataAccessExampleConfig.py
@@ -4,7 +4,7 @@
 
 import sys
 from AthenaConfiguration.ComponentFactory import CompFactory
-from AthenaCommon.Constants import VERBOSE, INFO
+from AthenaCommon.Constants import INFO, WARNING
 
 Cmake_working_dir = sys.argv[1]
 print("Cmake_working_dir = ", Cmake_working_dir)
@@ -30,6 +30,7 @@ def TrackerDataAccessExampleCfg(flags, name="TrackerDataAccessExampleAlg", **kwa
 if __name__ == "__main__":
     from AthenaCommon.Configurable import Configurable
     from CalypsoConfiguration.AllConfigFlags import ConfigFlags
+    from AthenaCommon.Logging import logging
 
     Configurable.configurableRun3Behavior = True
     
@@ -66,16 +67,11 @@ if __name__ == "__main__":
 
 # Configure verbosity    
     # ConfigFlags.dump()
-    # logging.getLogger('forcomps').setLevel(VERBOSE)
-    acc.foreach_component("*").OutputLevel = VERBOSE
+    logging.getLogger('forcomps').setLevel(WARNING)
+    acc.foreach_component("*").OutputLevel = INFO
     acc.foreach_component("*ClassID*").OutputLevel = INFO
+    acc.foreach_component("*TrackerDataAccess*").OutputLevel = WARNING
     # log.setLevel(VERBOSE)
 
-    acc.getService("FaserByteStreamInputSvc").DumpFlag = True
-    acc.getService("FaserEventSelector").OutputLevel = VERBOSE
-    acc.getService("FaserByteStreamInputSvc").OutputLevel = VERBOSE
-    acc.getService("FaserByteStreamCnvSvc").OutputLevel = VERBOSE
-    acc.getService("FaserByteStreamAddressProviderSvc").OutputLevel = VERBOSE
-    acc.getService("MessageSvc").Format = "% F%40W%S%7W%R%T %0W%M"
 # Execute and finish
     sys.exit(int(acc.run(maxEvents=-1).isFailure()))
diff --git a/MagneticField/MagFieldElements/MagFieldElements/FaserFieldCache.h b/MagneticField/MagFieldElements/MagFieldElements/FaserFieldCache.h
index 6011b4658c310962a68f6dd63d65caa81435617e..3e1c8df5c9e04f9ae4b6c0b3759780529dfe639f 100644
--- a/MagneticField/MagFieldElements/MagFieldElements/FaserFieldCache.h
+++ b/MagneticField/MagFieldElements/MagFieldElements/FaserFieldCache.h
@@ -37,11 +37,12 @@ namespace MagField {
     // : public ::AthMessaging
     {
     public:
-        FaserFieldCache();
+        FaserFieldCache() = default;
         // ** constructor to setup with field scale and magnetic field service for first access to field */
         FaserFieldCache(double fieldScale,
                         const FaserFieldMap* fieldMap);
-        FaserFieldCache& operator= (FaserFieldCache&& other)      = default;
+        FaserFieldCache& operator= (FaserFieldCache&& other) = default;
+        FaserFieldCache(FaserFieldCache&& other) = default;
         ~FaserFieldCache() = default; 
  
         /** get B field value at given position */
@@ -58,7 +59,6 @@ namespace MagField {
     
         FaserFieldCache(const FaserFieldCache& other)             = delete;
         FaserFieldCache& operator= (const FaserFieldCache& other) = delete;
-        FaserFieldCache(FaserFieldCache&& other)                  = delete;
 
         inline bool fillFieldCache(double x, double y, double z);
         // inline bool fillFieldCacheZR(double z, double r);
diff --git a/MagneticField/MagFieldElements/src/FaserFieldCache.cxx b/MagneticField/MagFieldElements/src/FaserFieldCache.cxx
index 5d08317efd2b4e9847046bee2393b6e808a489e6..040dc170ba0b1ec106dc2bf2aa4449b8159ba01d 100644
--- a/MagneticField/MagFieldElements/src/FaserFieldCache.cxx
+++ b/MagneticField/MagFieldElements/src/FaserFieldCache.cxx
@@ -12,9 +12,6 @@
 #include "MagFieldElements/FaserFieldCache.h"
 
 /// Constructor
-MagField::FaserFieldCache::FaserFieldCache()
-{}
-
 MagField::FaserFieldCache::FaserFieldCache(double scale,
                                            const FaserFieldMap* fieldMap)
     :
diff --git a/Tracking/Acts/ActsInterop/CMakeLists.txt_disabled b/Tracking/Acts/ActsInterop/CMakeLists.txt
similarity index 100%
rename from Tracking/Acts/ActsInterop/CMakeLists.txt_disabled
rename to Tracking/Acts/ActsInterop/CMakeLists.txt
diff --git a/Tracking/Acts/FaserActsGeometry/CMakeLists.txt_disabled b/Tracking/Acts/FaserActsGeometry/CMakeLists.txt
similarity index 100%
rename from Tracking/Acts/FaserActsGeometry/CMakeLists.txt_disabled
rename to Tracking/Acts/FaserActsGeometry/CMakeLists.txt
diff --git a/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FASERMagneticFieldWrapper.h b/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FASERMagneticFieldWrapper.h
index bd1c217f6ce986bf181421c57f549a30e2e8db52..091cc8c2734df9a7eb787bf702f6773d805ed1bb 100644
--- a/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FASERMagneticFieldWrapper.h
+++ b/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FASERMagneticFieldWrapper.h
@@ -12,56 +12,76 @@
 #include "Acts/Definitions/Algebra.hpp"
 #include "Acts/Definitions/Units.hpp"
 #include "Acts/MagneticField/MagneticFieldContext.hpp"
+#include "Acts/MagneticField/MagneticFieldProvider.hpp"
 
-class FASERMagneticFieldWrapper
-{
-
+class FASERMagneticFieldWrapper final : public Acts::MagneticFieldProvider {
 
   public:
 
     struct Cache {
 
       Cache(const Acts::MagneticFieldContext mctx) {
-        const auto faserField = mctx.get<const FaserFieldCacheCondObj*>();
+        const auto* faserField = mctx.get<const FaserFieldCacheCondObj*>();
         faserField->getInitializedCache(fieldCache);
       }
 
       MagField::FaserFieldCache fieldCache;
     };
 
-
     FASERMagneticFieldWrapper() = default;
 
-    Acts::Vector3
-    getField(const Acts::Vector3& pos, Cache& cache) const
-      {
-	double pos0[]{pos.x(), pos.y(), pos.z()};
-	double bfield0[]{0., 0., 0.};
-	cache.fieldCache.getField(pos0, bfield0);
-	Acts::Vector3 bfield(bfield0[0], bfield0[1], bfield0[2]);
 
-	bfield *= m_bFieldUnit; // kT -> T;
+    MagneticFieldProvider::Cache 
+    makeCache(const Acts::MagneticFieldContext& mctx) const override {
+      return Acts::MagneticFieldProvider::Cache::make<Cache>(mctx);
+    }
 
-	return bfield;
-      }
+    Acts::Result<Acts::Vector3>
+    getField(const Acts::Vector3& position, Acts::MagneticFieldProvider::Cache& gcache) const override {
+      Cache& cache = gcache.get<Cache>();
+      double posXYZ[3];
+      posXYZ[0] = position.x();
+      posXYZ[1] = position.y();
+      posXYZ[2] = position.z();
+      double BField[3];
 
-    Acts::Vector3
-    getFieldGradient(const Acts::Vector3& position, Acts::ActsMatrix<3, 3>& gradient, Cache& cache) const
-      {
-	double position0[]{position.x(), position.y(), position.z()};
-	double bfield0[]{0., 0., 0.};
-	double grad[9];
-	cache.fieldCache.getField(position0, bfield0, grad);
-	Acts::Vector3 bfield(bfield0[0], bfield0[1], bfield0[2]);
-        Acts::ActsMatrix<3, 3> tempGrad;
-	tempGrad << grad[0], grad[1], grad[2], grad[3], grad[4], grad[5], grad[6], grad[7], grad[8]; 
-	gradient = tempGrad;
-
-	bfield *= m_bFieldUnit; // kT -> T;
-	gradient *= m_bFieldUnit;
-
-	return bfield;
-      }
+      cache.fieldCache.getField(posXYZ, BField);
+
+      // Magnetic field
+      Acts::Vector3 bfield{BField[0],BField[1],BField[2]};
+
+      bfield *= m_bFieldUnit; // kT -> T;
+
+      return Acts::Result<Acts::Vector3>::success(bfield);
+    }
+
+    Acts::Result<Acts::Vector3>
+    getFieldGradient(const Acts::Vector3& position,
+                    Acts::ActsMatrix<3, 3>& gradient,
+                    Acts::MagneticFieldProvider::Cache& gcache) const override
+    {
+      Cache& cache = gcache.get<Cache>();
+      double posXYZ[3];
+      posXYZ[0] = position.x();
+      posXYZ[1] = position.y();
+      posXYZ[2] = position.z();
+      double BField[3];
+      double grad[9];
+
+      cache.fieldCache.getField(posXYZ, BField, grad);
+
+      // Magnetic field
+      Acts::Vector3 bfield{BField[0], BField[1],BField[2]};
+      Acts::ActsMatrix<3, 3> tempGrad;
+      tempGrad << grad[0], grad[1], grad[2], grad[3], grad[4], grad[5], grad[6], grad[7], grad[8]; 
+      gradient = tempGrad;
+
+
+      bfield *= m_bFieldUnit; // kT -> T;
+      gradient *= m_bFieldUnit;
+
+      return Acts::Result<Acts::Vector3>::success(bfield);
+    }
 
 
   private:
diff --git a/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsExtrapolationTool.h b/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsExtrapolationTool.h
index ee765dd235b4d139d336edabb21a1605169fc483..2f1d2e8aa2affce99cc187eca841aa085204021a 100644
--- a/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsExtrapolationTool.h
+++ b/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsExtrapolationTool.h
@@ -11,6 +11,8 @@
 #include "GaudiKernel/ServiceHandle.h"
 #include "Gaudi/Property.h"
 #include "GaudiKernel/EventContext.h"
+#include "TrkEventPrimitives/ParticleHypothesis.h"
+#include "TrkEventPrimitives/PdgToParticleHypothesis.h"
 
 // Need to include this early; otherwise, we run into errors with
 // ReferenceWrapperAnyCompat in clang builds due the is_constructable
@@ -27,7 +29,6 @@
 #include "FaserActsGeometry/FASERMagneticFieldWrapper.h"
 
 // ACTS
-#include "Acts/Propagator/EigenStepper.hpp"
 #include "Acts/Propagator/detail/SteppingLogger.hpp"
 #include "Acts/Propagator/Navigator.hpp"
 #include "Acts/Propagator/StandardAborters.hpp"
@@ -111,11 +112,8 @@ public:
   getMagneticFieldContext(const EventContext& ctx) const override;
 
 
-
 private:
-
   std::unique_ptr<ActsExtrapolationDetail::VariantPropagator> m_varProp;
-
   std::unique_ptr<const Acts::Logger> m_logger{nullptr};
 
   // Read handle for conditions object to get the field cache
@@ -127,16 +125,14 @@ private:
   Gaudi::Property<std::vector<double>> m_constantFieldVector{this, "ConstantFieldVector", {0, 0, 0}};
 
   Gaudi::Property<double> m_ptLoopers{this, "PtLoopers", 300, "PT loop protection threshold. Will be converted to Acts MeV unit"};
-
   Gaudi::Property<double> m_maxStepSize{this, "MaxStepSize", 10, "Max step size in Acts m unit"};
+  Gaudi::Property<double> m_maxStep{this, "MaxSteps", 4000, "Max number of steps"};
 
   // Material inteaction option
   Gaudi::Property<bool> m_interactionMultiScatering{this, "InteractionMultiScatering", false, "Whether to consider multiple scattering in the interactor"};
   Gaudi::Property<bool> m_interactionEloss{this, "InteractionEloss", false, "Whether to consider energy loss in the interactor"};
   Gaudi::Property<bool> m_interactionRecord{this, "InteractionRecord", false, "Whether to record all material interactions"};
-  
 };
 
 
-
 #endif
diff --git a/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsMaterialJsonWriterTool.h b/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsMaterialJsonWriterTool.h
index e3959e307137f5b49633a48f753b57d9d308e554..c29a42c5c2ccf21db1c4c86a4c8fb4defd82a2b9 100644
--- a/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsMaterialJsonWriterTool.h
+++ b/Tracking/Acts/FaserActsGeometry/FaserActsGeometry/FaserActsMaterialJsonWriterTool.h
@@ -15,9 +15,7 @@
 #include "FaserActsGeometryInterfaces/IFaserActsMaterialJsonWriterTool.h"
 
 // ACTS
-#include "Acts/Geometry/TrackingGeometry.hpp"
-#include "Acts/Plugins/Json/JsonGeometryConverter.hpp"
-#include "FaserActsGeometry/FaserActsJsonGeometryConverter.h"
+#include "Acts/Plugins/Json/MaterialMapJsonConverter.hpp"
 
 namespace Acts {
   class TrackingGeometry;
@@ -36,7 +34,7 @@ public:
 
   virtual
   void
-  write(const Acts::FaserActsJsonGeometryConverter::DetectorMaterialMaps& detMaterial) const override;
+  write(const Acts::MaterialMapJsonConverter::DetectorMaterialMaps& detMaterial) const override;
 
   virtual
   void
@@ -45,7 +43,7 @@ public:
 
 private:
 
-Acts::FaserActsJsonGeometryConverter::Config m_cfg;
+Acts::MaterialMapJsonConverter::Config m_cfg;
 
   Gaudi::Property<std::string> m_filePath{this, "OutputFile", "material-maps.json", "Output json file for the Material Map"};
   Gaudi::Property<bool> m_processSensitives{this, "processSensitives", true, "Write sensitive surface to the json file"};
@@ -54,7 +52,7 @@ Acts::FaserActsJsonGeometryConverter::Config m_cfg;
   Gaudi::Property<bool> m_processBoundaries{this, "processBoundaries", true, "Write boundary surface to the json file"};
   Gaudi::Property<bool> m_processVolumes{this, "processVolumes", true, "Write volume to the json file"};
   Gaudi::Property<bool> m_processDenseVolumes{this, "processDenseVolumes", false, "Write dense volume to the json file"};
-  Gaudi::Property<bool> m_processnonmaterial{this, "processnonmaterial", false, "Add proto material to all surfaces and volumes"};
+  Gaudi::Property<bool> m_processNonMaterial{this, "processnonmaterial", false, "Add proto material to all surfaces and volumes"};
 };
 
 #endif
diff --git a/Tracking/Acts/FaserActsGeometry/src/FaserActsExtrapolationTool.cxx b/Tracking/Acts/FaserActsGeometry/src/FaserActsExtrapolationTool.cxx
index db23d5c7c3ea32ae9504c7e83738625da5e3c9ab..e84a69c6a3fe54ee30ecb046a0606a1e264da5e5 100644
--- a/Tracking/Acts/FaserActsGeometry/src/FaserActsExtrapolationTool.cxx
+++ b/Tracking/Acts/FaserActsGeometry/src/FaserActsExtrapolationTool.cxx
@@ -33,8 +33,8 @@
 
 namespace ActsExtrapolationDetail {
   using VariantPropagatorBase = boost::variant<
-    Acts::Propagator<Acts::EigenStepper<FASERMagneticFieldWrapper>, Acts::Navigator>,
-    Acts::Propagator<Acts::EigenStepper<Acts::ConstantBField>, Acts::Navigator>
+    Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>,
+    Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>
   >;
 
   class VariantPropagator : public VariantPropagatorBase
@@ -77,27 +77,33 @@ FaserActsExtrapolationTool::initialize()
   std::shared_ptr<const Acts::TrackingGeometry> trackingGeometry
     = m_trackingGeometryTool->trackingGeometry();
 
-  Acts::Navigator navigator(trackingGeometry);
+  Acts::Navigator navigator( Acts::Navigator::Config{ trackingGeometry } );
 
   if (m_fieldMode == "FASER") {
     ATH_MSG_INFO("Using FASER magnetic field service");
-    using BField_t = FASERMagneticFieldWrapper;
     ATH_CHECK( m_fieldCondObjInputKey.initialize() );
-    BField_t bField;
-    auto stepper = Acts::EigenStepper<BField_t>(std::move(bField));
+    auto bField = std::make_shared<FASERMagneticFieldWrapper>();
+    auto stepper = Acts::EigenStepper<>(std::move(bField));
     auto propagator = Acts::Propagator<decltype(stepper), Acts::Navigator>(std::move(stepper),
                                                                       std::move(navigator));
     m_varProp = std::make_unique<VariantPropagator>(propagator);
   }
   else if (m_fieldMode == "Constant") {
-    std::vector<double> constantFieldVector = m_constantFieldVector;
-    double Bx = constantFieldVector.at(0);
-    double By = constantFieldVector.at(1);
-    double Bz = constantFieldVector.at(2);
-    ATH_MSG_INFO("Using constant magnetic field: (Bx, By, Bz) = (" << Bx << ", " << By << ", " << Bz << ")");
-    using BField_t = Acts::ConstantBField;
-    BField_t bField(Bx, By, Bz);
-    auto stepper = Acts::EigenStepper<BField_t>(std::move(bField));
+    if (m_constantFieldVector.value().size() != 3)
+    {
+      ATH_MSG_ERROR("Incorrect field vector size. Using empty field.");
+      return StatusCode::FAILURE; 
+    }
+    
+    Acts::Vector3 constantFieldVector = Acts::Vector3(m_constantFieldVector[0], 
+                                                      m_constantFieldVector[1], 
+                                                      m_constantFieldVector[2]);
+
+    ATH_MSG_INFO("Using constant magnetic field: (Bx, By, Bz) = (" << m_constantFieldVector[0] << ", " 
+                                                                   << m_constantFieldVector[1] << ", " 
+                                                                   << m_constantFieldVector[2] << ")");
+    auto bField = std::make_shared<Acts::ConstantBField>(constantFieldVector);
+    auto stepper = Acts::EigenStepper<>(std::move(bField));
     auto propagator = Acts::Propagator<decltype(stepper), Acts::Navigator>(std::move(stepper),
                                                                       std::move(navigator));
     m_varProp = std::make_unique<VariantPropagator>(propagator);
@@ -138,6 +144,7 @@ FaserActsExtrapolationTool::propagationSteps(const EventContext& ctx,
           < m_ptLoopers * 1_MeV);
 
     options.maxStepSize = m_maxStepSize * 1_m;
+    options.maxSteps = m_maxStep;
     options.direction = navDir;
 
     auto& mInteractor = options.actionList.get<Acts::MaterialInteractor>();
@@ -150,7 +157,7 @@ FaserActsExtrapolationTool::propagationSteps(const EventContext& ctx,
     auto res = boost::apply_visitor([&](const auto& propagator) -> ResultType {
         auto result = propagator.propagate(startParameters, options);
         if (!result.ok()) {
-        return result.error();
+          return result.error();
         }
         auto& propRes = *result;
 
@@ -160,17 +167,19 @@ FaserActsExtrapolationTool::propagationSteps(const EventContext& ctx,
         output.second = std::move(materialResult);
         // try to force return value optimization, not sure this is necessary
         return std::move(output);
-        }, *m_varProp);
+    }, *m_varProp);
 
     if (!res.ok()) {
-      ATH_MSG_ERROR("Got error during propagation:" << res.error() << " " << res.error().message()
-          << ". Returning empty step vector.");
+      ATH_MSG_ERROR("Got error during propagation: "
+  		  << res.error() << " " << res.error().message()
+                    << ". Returning empty step vector.");
       return {};
     }
+    output = std::move(*res);
 
     ATH_MSG_VERBOSE("Collected " << output.first.size() << " steps");
-    if (output.first.size() == 0) {
-       ATH_MSG_WARNING("ZERO steps returned by stepper, that is not typically a good sign");
+    if(output.first.size() == 0) {
+      ATH_MSG_WARNING("ZERO steps returned by stepper, that is not typically a good sign");
     }
 
     ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " end");
@@ -207,6 +216,7 @@ FaserActsExtrapolationTool::propagate(const EventContext& ctx,
     = (Acts::VectorHelpers::perp(startParameters.momentum())
        < m_ptLoopers * 1_MeV);
   options.maxStepSize = m_maxStepSize * 1_m;
+  options.maxSteps = m_maxStep;
   options.direction = navDir;
 
   auto& mInteractor = options.actionList.get<Acts::MaterialInteractor>();
@@ -256,6 +266,7 @@ FaserActsExtrapolationTool::propagationSteps(const EventContext& ctx,
     = (Acts::VectorHelpers::perp(startParameters.momentum())
        < m_ptLoopers * 1_MeV);
   options.maxStepSize = m_maxStepSize * 1_m;
+  options.maxSteps = m_maxStep;
   options.direction = navDir;
 
   auto& mInteractor = options.actionList.get<Acts::MaterialInteractor>();
@@ -284,6 +295,7 @@ FaserActsExtrapolationTool::propagationSteps(const EventContext& ctx,
                   << ". Returning empty step vector.");
     return {};
   }
+  output = std::move(*res);
 
   ATH_MSG_VERBOSE("Collected " << output.first.size() << " steps");
   if (output.first.size() == 0) {
@@ -307,7 +319,6 @@ FaserActsExtrapolationTool::propagate(const EventContext& ctx,
 
   Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
   const FaserActsGeometryContext& gctx
-    //= m_trackingGeometryTool->getGeometryContext(ctx);
     = m_trackingGeometryTool->getGeometryContext(ctx);
 
   auto anygctx = gctx.context();
@@ -324,6 +335,7 @@ FaserActsExtrapolationTool::propagate(const EventContext& ctx,
     = (Acts::VectorHelpers::perp(startParameters.momentum())
        < m_ptLoopers * 1_MeV);
   options.maxStepSize = m_maxStepSize * 1_m;
+  options.maxSteps = m_maxStep;
   options.direction = navDir;
 
   auto& mInteractor = options.actionList.get<Acts::MaterialInteractor>();
@@ -355,4 +367,3 @@ Acts::MagneticFieldContext FaserActsExtrapolationTool::getMagneticFieldContext(c
 
   return Acts::MagneticFieldContext(fieldCondObj);
 }
-
diff --git a/Tracking/Acts/FaserActsGeometry/src/FaserActsMaterialJsonWriterTool.cxx b/Tracking/Acts/FaserActsGeometry/src/FaserActsMaterialJsonWriterTool.cxx
index fe033f8eba019c77761c8edb6f8e89501f31bd89..feeb6f7a79425845048565d73f47f044dad45ccf 100644
--- a/Tracking/Acts/FaserActsGeometry/src/FaserActsMaterialJsonWriterTool.cxx
+++ b/Tracking/Acts/FaserActsGeometry/src/FaserActsMaterialJsonWriterTool.cxx
@@ -34,16 +34,16 @@ FaserActsMaterialJsonWriterTool::initialize()
   m_cfg.processBoundaries = m_processBoundaries;
   m_cfg.processVolumes = m_processVolumes;
   m_cfg.processDenseVolumes = m_processDenseVolumes;
-  m_cfg.processnonmaterial = m_processnonmaterial;
+  m_cfg.processNonMaterial = m_processNonMaterial;
   
   return StatusCode::SUCCESS;
 }
 
 void
-FaserActsMaterialJsonWriterTool::write(const Acts::FaserActsJsonGeometryConverter::DetectorMaterialMaps& detMaterial) const
+FaserActsMaterialJsonWriterTool::write(const Acts::MaterialMapJsonConverter::DetectorMaterialMaps& detMaterial) const
 {
   // Evoke the converter
-  Acts::FaserActsJsonGeometryConverter jmConverter(m_cfg);
+  Acts::MaterialMapJsonConverter jmConverter(m_cfg);
   auto jout = jmConverter.materialMapsToJson(detMaterial);
   // And write the file
   std::ofstream ofj(m_filePath);
@@ -54,7 +54,7 @@ void
 FaserActsMaterialJsonWriterTool::write(const Acts::TrackingGeometry& tGeometry) const
 {
   // Evoke the converter
-  Acts::FaserActsJsonGeometryConverter jmConverter(m_cfg);
+  Acts::MaterialMapJsonConverter jmConverter(m_cfg);
   auto jout = jmConverter.trackingGeometryToJson(tGeometry);
   // And write the file
   std::ofstream ofj(m_filePath);
diff --git a/Tracking/Acts/FaserActsGeometry/src/FaserActsSurfaceMappingTool.cxx b/Tracking/Acts/FaserActsGeometry/src/FaserActsSurfaceMappingTool.cxx
index 4920fb5ce678da084cedcb555b4a5e83044bc87c..ac647013bd177fb74ec5eaa1d26ae74935b3cfb1 100644
--- a/Tracking/Acts/FaserActsGeometry/src/FaserActsSurfaceMappingTool.cxx
+++ b/Tracking/Acts/FaserActsGeometry/src/FaserActsSurfaceMappingTool.cxx
@@ -38,7 +38,7 @@ FaserActsSurfaceMappingTool::initialize()
 
   m_trackingGeometry = m_trackingGeometryTool->trackingGeometry();
 
-  Acts::Navigator navigator(m_trackingGeometry);
+  Acts::Navigator navigator( Acts::Navigator::Config{ m_trackingGeometry } );
   // Make stepper and propagator
   SlStepper stepper;
   StraightLinePropagator propagator = StraightLinePropagator(std::move(stepper), std::move(navigator));
diff --git a/Tracking/Acts/FaserActsGeometry/src/FaserActsVolumeMappingTool.cxx b/Tracking/Acts/FaserActsGeometry/src/FaserActsVolumeMappingTool.cxx
index 2c863aa2efa9ce40479422db938221d9b813ff78..796ad74e4878cd72e6eae62cfea7333b94bcdc11 100644
--- a/Tracking/Acts/FaserActsGeometry/src/FaserActsVolumeMappingTool.cxx
+++ b/Tracking/Acts/FaserActsGeometry/src/FaserActsVolumeMappingTool.cxx
@@ -40,7 +40,7 @@ FaserActsVolumeMappingTool::initialize()
 
   m_trackingGeometry = m_trackingGeometryTool->trackingGeometry();
 
-  Acts::Navigator navigator(m_trackingGeometry);
+  Acts::Navigator navigator( Acts::Navigator::Config{ m_trackingGeometry } );
   // Make stepper and propagator
   SlStepper stepper;
   StraightLinePropagator propagator = StraightLinePropagator(std::move(stepper), std::move(navigator));
diff --git a/Tracking/Acts/FaserActsGeometryInterfaces/CMakeLists.txt_disabled b/Tracking/Acts/FaserActsGeometryInterfaces/CMakeLists.txt
similarity index 100%
rename from Tracking/Acts/FaserActsGeometryInterfaces/CMakeLists.txt_disabled
rename to Tracking/Acts/FaserActsGeometryInterfaces/CMakeLists.txt
diff --git a/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsExtrapolationTool.h b/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsExtrapolationTool.h
index 89ec77aa9598f49ac0660379862921ba7ca48901..05b16956611affd2a69a1301693db36a9be3aa12 100644
--- a/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsExtrapolationTool.h
+++ b/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsExtrapolationTool.h
@@ -9,6 +9,7 @@
 #include "GaudiKernel/IInterface.h"
 #include "GaudiKernel/IAlgTool.h"
 #include "GaudiKernel/EventContext.h"
+#include "TrkEventPrimitives/ParticleHypothesis.h"
 
 #include "Acts/Propagator/detail/SteppingLogger.hpp"
 #include "Acts/EventData/TrackParameters.hpp"
@@ -72,7 +73,6 @@ class IFaserActsExtrapolationTool : virtual public IAlgTool {
 
   virtual 
   Acts::MagneticFieldContext getMagneticFieldContext(const EventContext& ctx) const = 0;
-
 };
 
 #endif
diff --git a/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsMaterialJsonWriterTool.h b/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsMaterialJsonWriterTool.h
index 7fe13c593aaee7207a8da54909ee1e21eba09564..940cad83644a311bf30b5977c87a37ce17200678 100644
--- a/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsMaterialJsonWriterTool.h
+++ b/Tracking/Acts/FaserActsGeometryInterfaces/FaserActsGeometryInterfaces/IFaserActsMaterialJsonWriterTool.h
@@ -9,9 +9,7 @@
 #include "GaudiKernel/IInterface.h"
 #include "GaudiKernel/IAlgTool.h"
 
-#include "Acts/Geometry/TrackingGeometry.hpp"
-#include "Acts/Plugins/Json/JsonGeometryConverter.hpp"
-#include "FaserActsGeometry/FaserActsJsonGeometryConverter.h"
+#include "Acts/Plugins/Json/MaterialMapJsonConverter.hpp"
 
 namespace Acts {
   class TrackingGeometry;
@@ -24,7 +22,7 @@ public:
 
   virtual
   void
-  write(const Acts::FaserActsJsonGeometryConverter::DetectorMaterialMaps& detMaterial) const = 0;
+  write(const Acts::MaterialMapJsonConverter::DetectorMaterialMaps& detMaterial) const = 0;
 
   virtual
   void
diff --git a/Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt_disabled b/Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt
similarity index 100%
rename from Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt_disabled
rename to Tracking/Acts/FaserActsKalmanFilter/CMakeLists.txt
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h
index 47edb716ae6c45f0d19cb7ec942bcec12b355c63..3d147019b115c7d7f6818bb06c7aef1c65c6bfec 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/CombinatorialKalmanFilterAlg.h
@@ -22,7 +22,7 @@ class CombinatorialKalmanFilterAlg : public AthReentrantAlgorithm {
   StatusCode finalize() override;
 
   using TrackFinderOptions =
-      Acts::CombinatorialKalmanFilterOptions<MeasurementCalibrator, Acts::MeasurementSelector>;
+      Acts::CombinatorialKalmanFilterOptions<IndexSourceLinkAccessor, MeasurementCalibrator, Acts::MeasurementSelector>;
   using TrackFinderResult = std::vector<
       Acts::Result<Acts::CombinatorialKalmanFilterResult<IndexSourceLink>>>;
   using TrackFinderFunction = std::function<TrackFinderResult(
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsGeometryContainers.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsGeometryContainers.h
index a8e93a2cf9b588de4899271505c68dc46ac35873..2f049c7d6429d5d40c6656bb43240950ea19261a 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsGeometryContainers.h
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsGeometryContainers.h
@@ -87,3 +87,34 @@ boost::container::flat_multiset<T, detail::CompareGeometryId>;
 template <typename T>
 using GeometryIdMultimap =
 GeometryIdMultiset<std::pair<Acts::GeometryIdentifier, T>>;
+
+/// The accessor for the GeometryIdMultiset container
+///
+/// It wraps up a few lookup methods to be used in the Combinatorial Kalman
+/// Filter
+template <typename T>
+struct GeometryIdMultisetAccessor {
+  using Container = GeometryIdMultiset<T>;
+  using Key = Acts::GeometryIdentifier;
+  using Value = typename GeometryIdMultiset<T>::value_type;
+  using Iterator = typename GeometryIdMultiset<T>::const_iterator;
+
+  // pointer to the container
+  const Container* container = nullptr;
+
+  // count the number of elements with requested geoId
+  size_t count(const Acts::GeometryIdentifier& geoId) const {
+    assert(container != nullptr);
+    return container->count(geoId);
+  }
+
+  // get the range of elements with requested geoId
+  std::pair<Iterator, Iterator> range(
+      const Acts::GeometryIdentifier& geoId) const {
+    assert(container != nullptr);
+    return container->equal_range(geoId);
+  }
+
+  // get the element using the iterator
+  const Value& at(const Iterator& it) const { return *it; }
+};
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h
index 2cdf9b4a75de9c39e50686a54bb4988323a90811..fd7801c9eef4aa76b4f71215996983cc1a9efd5e 100755
--- a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/FaserActsKalmanFilterAlg.h
@@ -87,6 +87,8 @@ public:
       const Acts::KalmanFitterOptions<MeasurementCalibrator, Acts::VoidOutlierFinder>&,
       const std::vector<const Acts::Surface*>&)>;
 
+  using BoundVector = Acts::ActsVector<6>;
+
   // Create the fitter function implementation.
   static FitterFunction
   makeFitterFunction(
diff --git a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/IndexSourceLink.h b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/IndexSourceLink.h
index 9cb2706cc83256198e12936c62a293e7737002a4..99d101519030fca1d4fd7904bc7549b22a39a6c2 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/IndexSourceLink.h
+++ b/Tracking/Acts/FaserActsKalmanFilter/FaserActsKalmanFilter/IndexSourceLink.h
@@ -70,3 +70,8 @@ private:
 /// Since the source links provide a `.geometryId()` accessor, they can be
 /// stored in an ordered geometry container.
 using IndexSourceLinkContainer = GeometryIdMultiset<IndexSourceLink>;
+/// Accessor for the above source link container
+///
+/// It wraps up a few lookup methods to be used in the Combinatorial Kalman
+/// Filter
+using IndexSourceLinkAccessor = GeometryIdMultisetAccessor<IndexSourceLink>;
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx
index fa80a3f686e13e0eadfc2ca9f61f66ac4e9a88f0..564760f72f7e5a502d4e21f9474a1f00c9e52221 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/CombinatorialKalmbanFilterAlg.cxx
@@ -107,12 +107,12 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
     {Acts::GeometryIdentifier(), {chi2Max, nMax}},
   };
   std::unique_ptr<const Acts::Logger> logger
-      = Acts::getDefaultLogger("CombinatorialKalmanFilter", Acts::Logging::INFO);
+      = Acts::getDefaultLogger("CombinatorialKalmanFilter", Acts::Logging::VERBOSE);
 
   // Set the CombinatorialKalmanFilter options
   CombinatorialKalmanFilterAlg::TrackFinderOptions options(
       geoContext, magFieldContext, calibContext,
-      MeasurementCalibrator(measurements),
+      IndexSourceLinkAccessor(), MeasurementCalibrator(measurements),
       Acts::MeasurementSelector(measurementSelectorCfg),
       Acts::LoggerWrapper{*logger}, pOptions, &(*pSurface));
 
@@ -135,7 +135,7 @@ StatusCode CombinatorialKalmanFilterAlg::execute(const EventContext& ctx) const
       const auto& trackFindingOutput = result.value();
       // Create a Trajectories result struct
       trajectories.emplace_back(std::move(trackFindingOutput.fittedStates),
-                                std::move(trackFindingOutput.trackTips),
+                                std::move(trackFindingOutput.lastMeasurementIndices),
                                 std::move(trackFindingOutput.fittedParameters));
     } else {
       ATH_MSG_WARNING("Track finding failed for seed " << iseed << " with error"
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx
index fe85f076d47e0a87c95faa8a538c9d26700560ae..9d11c2f800b559ebb694765e7286cea85d62ee8d 100755
--- a/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/FaserActsKalmanFilterAlg.cxx
@@ -83,8 +83,8 @@ using Fitter = Acts::KalmanFitter<Propagator, Updater, Smoother>;
 
 namespace ActsExtrapolationDetail {
   using VariantPropagatorBase = boost::variant<
-      Acts::Propagator<Acts::EigenStepper<FASERMagneticFieldWrapper>, Acts::DirectNavigator>,
-      Acts::Propagator<Acts::EigenStepper<Acts::ConstantBField>, Acts::DirectNavigator>
+    Acts::Propagator<Acts::EigenStepper<>, Acts::DirectNavigator>,
+    Acts::Propagator<Acts::EigenStepper<>, Acts::DirectNavigator>
   >;
 
   class VariantPropagator : public VariantPropagatorBase
@@ -455,7 +455,16 @@ StatusCode FaserActsKalmanFilterAlg::execute()
     const Acts::Vector4 truthPosTime (pPos.x(), pPos.y(), pPos.z(), time);
     const Acts::Vector3 truthMomentum_dir = pMom.normalized();
     double truthMomentum_abs = pMom.norm();
-    Acts::BoundTrackParameters startParameters(initSurface, geoctx, truthPosTime, truthMomentum_dir, truthMomentum_abs, charge, std::nullopt);
+
+    BoundVector params = BoundVector::Zero();
+    params[Acts::eBoundLoc0] = pPos.x();
+    params[Acts::eBoundLoc1] = pPos.y();
+    params[Acts::eBoundPhi] = Acts::VectorHelpers::phi(pMom.normalized());
+    params[Acts::eBoundTheta] = Acts::VectorHelpers::theta(pMom.normalized());
+    params[Acts::eBoundQOverP] = charge/p;
+    params[Acts::eBoundTime] = time;
+
+    Acts::BoundTrackParameters startParameters(initSurface, params, charge, std::nullopt);
     auto truthParam = m_extrapolationTool->propagate(Gaudi::Hive::currentContext(), startParameters, *pSurface);
     std::cout << "truth pos on 1st layer: " << truthParam->position(geoctx) << std::endl;
     std::cout << "truth mom on 1st layer: " << truthParam->momentum() << std::endl;
@@ -495,32 +504,39 @@ StatusCode FaserActsKalmanFilterAlg::execute()
     // navigator.resolveMaterial  = true;
     // navigator.resolveSensitive = true;
 
-    ActsExtrapolationDetail::VariantPropagator* varProp {nullptr};
+    std::unique_ptr<ActsExtrapolationDetail::VariantPropagator> varProp;
 
     if (m_fieldMode == "FASER") {
       ATH_MSG_INFO("Using FASER magnetic field service");
-      using BField_t = FASERMagneticFieldWrapper;
-      BField_t bField;
-      auto stepper = Acts::EigenStepper<BField_t>(std::move(bField));
+      ATH_CHECK( m_fieldCondObjInputKey.initialize() );
+      auto bField = std::make_shared<FASERMagneticFieldWrapper>();
+      auto stepper = Acts::EigenStepper<>(std::move(bField));
       auto propagator = Acts::Propagator<decltype(stepper), Acts::DirectNavigator>(std::move(stepper),
                                                                                    std::move(navigator));
-      varProp = new VariantPropagator(propagator);
+      varProp = std::make_unique<VariantPropagator>(propagator);
     }
     else if (m_fieldMode == "Constant") {
-      std::vector<double> constantFieldVector = m_constantFieldVector;
-      double Bx = constantFieldVector.at(0);
-      double By = constantFieldVector.at(1);
-      double Bz = constantFieldVector.at(2);
-      ATH_MSG_INFO("Using constant magnetic field: (Bx, By, Bz) = (" << Bx << ", " << By << ", " << Bz << ")");
-      using BField_t = Acts::ConstantBField;
-      BField_t bField(Bx, By, Bz);
-      auto stepper = Acts::EigenStepper<BField_t>(std::move(bField));
+      if (m_constantFieldVector.value().size() != 3)
+      {
+        ATH_MSG_ERROR("Incorrect field vector size. Using empty field.");
+        return StatusCode::FAILURE; 
+      }
+
+      Acts::Vector3 constantFieldVector = Acts::Vector3(m_constantFieldVector[0], 
+                                                        m_constantFieldVector[1], 
+                                                        m_constantFieldVector[2]);
+
+      ATH_MSG_INFO("Using constant magnetic field: (Bx, By, Bz) = (" << m_constantFieldVector[0] << ", " 
+                                                                     << m_constantFieldVector[1] << ", " 
+                                                                     << m_constantFieldVector[2] << ")");
+      auto bField = std::make_shared<Acts::ConstantBField>(constantFieldVector);
+      auto stepper = Acts::EigenStepper<>(std::move(bField));
       auto propagator = Acts::Propagator<decltype(stepper), Acts::DirectNavigator>(std::move(stepper),
                                                                                    std::move(navigator));
-      varProp = new VariantPropagator(propagator);
+      varProp = std::make_unique<VariantPropagator>(propagator);
     }
 
-    auto fit = makeFitterFunction(varProp);
+    auto fit = makeFitterFunction(varProp.get());
     auto result = fit(sourceLinks, InitTrackParam, kfOptions, surfSequence);
 
     ATH_MSG_VERBOSE("Size of sourceLinks: " << sourceLinks.size());
@@ -533,7 +549,7 @@ StatusCode FaserActsKalmanFilterAlg::execute()
       // The track entry indices container. One element here.
       std::vector<size_t> trackTips;
       trackTips.reserve(1);
-      trackTips.emplace_back(fitOutput.trackTip);
+      trackTips.emplace_back(fitOutput.lastMeasurementIndex);
       // The fitted parameters container. One element (at most) here.
       IndexedParams indexedParams;
 
@@ -544,7 +560,7 @@ StatusCode FaserActsKalmanFilterAlg::execute()
         ATH_MSG_VERBOSE("  position: " << params.position(geoctx).transpose());
         ATH_MSG_VERBOSE("  momentum: " << params.momentum().transpose());
         // Push the fitted parameters to the container
-        indexedParams.emplace(fitOutput.trackTip, std::move(params));
+        indexedParams.emplace(fitOutput.lastMeasurementIndex, std::move(params));
       } else {
         ATH_MSG_DEBUG("No fitted paramemeters for track " << itrack);
       }
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/TrackFindingAlgorithmFunction.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/TrackFindingAlgorithmFunction.cxx
index be8182a882751bad2ba815bab90cbb496775b286..954906a0f4263c6e17f17143b23d4639c5d1107a 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/src/TrackFindingAlgorithmFunction.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/TrackFindingAlgorithmFunction.cxx
@@ -17,13 +17,13 @@
 
 using Updater = Acts::GainMatrixUpdater;
 using Smoother = Acts::GainMatrixSmoother;
-using Stepper = Acts::EigenStepper<FASERMagneticFieldWrapper>;
+using Stepper = Acts::EigenStepper<>;
 using Propagator = Acts::Propagator<Stepper, Acts::Navigator>;
 
 namespace ActsExtrapolationDetail {
   using VariantPropagatorBase = boost::variant<
-      Acts::Propagator<Acts::EigenStepper<FASERMagneticFieldWrapper>, Acts::Navigator>,
-      Acts::Propagator<Acts::EigenStepper<Acts::ConstantBField>, Acts::Navigator>
+      Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>,
+      Acts::Propagator<Acts::EigenStepper<>, Acts::Navigator>
   >;
 
   class VariantPropagator : public VariantPropagatorBase
@@ -60,31 +60,31 @@ CombinatorialKalmanFilterAlg::makeTrackFinderFunction(
   const std::string fieldMode = "FASER";
   const std::vector<double> constantFieldVector = {0., 0., 0.55};
 
-  Acts::Navigator navigator(trackingGeometry);
-  navigator.resolvePassive   = false;
-  navigator.resolveMaterial  = true;
-  navigator.resolveSensitive = true;
+  Acts::Navigator::Config cfg{trackingGeometry};
+  cfg.resolvePassive   = false;
+  cfg.resolveMaterial  = true;
+  cfg.resolveSensitive = true;
+  Acts::Navigator navigator( cfg );
 
-  ActsExtrapolationDetail::VariantPropagator* varProp {nullptr};
+  std::unique_ptr<ActsExtrapolationDetail::VariantPropagator> varProp;
 
   if (fieldMode == "FASER") {
-    using BField_t = FASERMagneticFieldWrapper;
-    BField_t bField;
-    auto stepper = Acts::EigenStepper<BField_t>(std::move(bField));
-    auto propagator = Acts::Propagator<decltype(stepper), Acts::Navigator>(std::move(stepper), std::move(navigator));
-    varProp = new VariantPropagator(propagator);
+    auto bField = std::make_shared<FASERMagneticFieldWrapper>();
+    auto stepper = Acts::EigenStepper<>(std::move(bField));
+    auto propagator = Acts::Propagator<decltype(stepper), Acts::Navigator>(std::move(stepper),
+                                                                      std::move(navigator));
+    varProp = std::make_unique<VariantPropagator>(propagator);
   }
   else if (fieldMode == "Constant") {
-    std::vector<double> constantFieldVector = constantFieldVector;
-    double Bx = constantFieldVector.at(0);
-    double By = constantFieldVector.at(1);
-    double Bz = constantFieldVector.at(2);
-    using BField_t = Acts::ConstantBField;
-    BField_t bField(Bx, By, Bz);
-    auto stepper = Acts::EigenStepper<BField_t>(std::move(bField));
+    Acts::Vector3 constantFieldVector = Acts::Vector3(constantFieldVector[0], 
+                                                      constantFieldVector[1], 
+                                                      constantFieldVector[2]);
+
+    auto bField = std::make_shared<Acts::ConstantBField>(constantFieldVector);
+    auto stepper = Acts::EigenStepper<>(std::move(bField));
     auto propagator = Acts::Propagator<decltype(stepper), Acts::Navigator>(std::move(stepper),
-     std::move(navigator));
-    varProp = new VariantPropagator(propagator);
+                                                                      std::move(navigator));
+    varProp = std::make_unique<VariantPropagator>(propagator);
   }
 
   return boost::apply_visitor([&](const auto& propagator) -> TrackFinderFunction {
diff --git a/Tracking/Acts/FaserActsKalmanFilter/src/TruthBasedInitialParameterTool.cxx b/Tracking/Acts/FaserActsKalmanFilter/src/TruthBasedInitialParameterTool.cxx
index f5b850d8a05877b9d7d48db65faadbff7cfac519..85b1036e415fb3f28f9f6b8ee37679afb60304bd 100644
--- a/Tracking/Acts/FaserActsKalmanFilter/src/TruthBasedInitialParameterTool.cxx
+++ b/Tracking/Acts/FaserActsKalmanFilter/src/TruthBasedInitialParameterTool.cxx
@@ -51,6 +51,8 @@ Acts::CurvilinearTrackParameters TruthBasedInitialParameterTool::getInitialParam
     }
   }
 
+  std::cout << "?? px = " << momentum.x() << " py = " << momentum.y() << " pz = " << momentum.z() << std::endl;
+
   Acts::Vector3 truthVertex = {vertex.x(), vertex.y(), vertex.z()}; // in mm
   Acts::Vector3 truthMomentum = {momentum.x() / 1000, momentum.y() / 1000, momentum.z() / 1000}; // in GeV
   m_simWriterTool->writeout(truthVertex, truthMomentum);