diff --git a/Algorithms/Digitization/src/DigitizationAlgorithm.cpp b/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
index 60608341164925467b3e2c01937d1f857e0c5967..8ed8426f9f1937cd3e1cd7333f48c32a415cd4a3 100644
--- a/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
+++ b/Algorithms/Digitization/src/DigitizationAlgorithm.cpp
@@ -151,4 +151,4 @@ FW::DigitizationAlgorithm::execute(const AlgorithmContext& context) const
   // write the clusters to the EventStore
   context.eventStore.add(m_cfg.clusterCollection, std::move(clusters));
   return FW::ProcessCode::SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.hpp b/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.hpp
index cc7d33fde5a7488e22bf397b9576508fd5176816..ca1026c5025d0778cd1df0984a4b774bf6b8f020 100644
--- a/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.hpp
+++ b/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.hpp
@@ -63,8 +63,9 @@ public:
     std::vector<double> parameterSigma = {10, 10, 0.02, 0.02, 1};
     /// Gaussian sigma used to smear the truth hit
     std::vector<double> measurementSigma = {30, 30};
-    /// Outlier chi2 cut during filtering and smoothing stage;
-    std::vector<double> outlierChi2Cut = {10, 5};
+    /// Measurement significance cut for outlier rejection during filtering and
+    /// smoothing stage;
+    std::vector<double> measurementSignificanceCut = {0.01, 0.05};
     /// TrajectoryEmulationTool config;
     TrajectoryEmulationTool::Config trajectoryEmulationToolConfig;
     /// indicator for hole and outlier emulation;
diff --git a/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.ipp b/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.ipp
index 010b4c935a0f47665beee3cbdf0fe43dbb7a932d..994a45022243e1d290225d80874bd3dde921d97c 100644
--- a/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.ipp
+++ b/Algorithms/Fitting/include/ACTFW/Fitting/FittingAlgorithm.ipp
@@ -25,10 +25,12 @@ FW::FittingAlgorithm<kalman_Fitter_t>::FittingAlgorithm(
         m_cfg.trajectoryEmulationToolConfig, level);
   }
 
-  std::map<Acts::OutlierSearchStage, double> olCriteria
-      = {{Acts::OutlierSearchStage::Filtering, m_cfg.outlierChi2Cut[0]},
-         {Acts::OutlierSearchStage::Smoothing, m_cfg.outlierChi2Cut[1]}};
-  m_outlierFinder = Acts::MinimalOutlierFinder{std::move(olCriteria)};
+  std::map<Acts::OutlierSearchStage, double> measSigCut
+      = {{Acts::OutlierSearchStage::Filtering,
+          m_cfg.measurementSignificanceCut[0]},
+         {Acts::OutlierSearchStage::Smoothing,
+          m_cfg.measurementSignificanceCut[1]}};
+  m_outlierFinder = Acts::MinimalOutlierFinder{std::move(measSigCut)};
 }
 
 template <typename kalman_Fitter_t>
@@ -57,7 +59,7 @@ FW::FittingAlgorithm<kalman_Fitter_t>::execute(
   std::vector<std::vector<TrackState>> fittedTracks;
 
   // Prepare the measurements for KalmanFitter
-  ACTS_DEBUG("Prepare the measurements and then tracks");
+  ACTS_VERBOSE("Prepare the measurements and then tracks");
   std::map<barcode_type, std::vector<Data::SimSourceLink>> sourceLinkMap;
   for (const Data::SimHit& hit : simHits) {
     // get the barcode of the particle associated to the hit
@@ -95,10 +97,11 @@ FW::FittingAlgorithm<kalman_Fitter_t>::execute(
     sourceLinkMap[barcode].push_back(sourceLink);
   }
 
-  ACTS_DEBUG("There are " << sourceLinkMap.size() << " tracks for this event ");
+  ACTS_VERBOSE("There are " << sourceLinkMap.size()
+                            << " tracks for this event ");
 
   // Get the truth particle
-  ACTS_DEBUG("Get truth particle.");
+  ACTS_VERBOSE("Get truth particle.");
   std::map<barcode_type, Data::SimParticle> particles;
   for (auto& vertex : simulatedEvent) {
     for (auto& particle : vertex.outgoing) {
@@ -113,18 +116,18 @@ FW::FittingAlgorithm<kalman_Fitter_t>::execute(
     itrack++;
     auto particle = particles.find(barcode)->second;
 
-    ACTS_DEBUG("Start processing itrack = "
-               << itrack << " with nStates = " << sourceLinks.size()
-               << " and truth particle id = " << barcode);
+    ACTS_VERBOSE("Start processing itrack = "
+                 << itrack << " with nStates = " << sourceLinks.size()
+                 << " and truth particle id = " << barcode);
 
     // get the truth particle info
     Acts::Vector3D pos = particle.position();
     Acts::Vector3D mom = particle.momentum();
     double         q   = particle.q();
-    ACTS_DEBUG("truth position = " << pos[0] << " : " << pos[1] << " : "
-                                   << pos[2]);
-    ACTS_DEBUG("truth momentum = " << mom[0] << " : " << mom[1] << " : "
-                                   << mom[2]);
+    ACTS_VERBOSE("truth position = " << pos[0] << " : " << pos[1] << " : "
+                                     << pos[2]);
+    ACTS_VERBOSE("truth momentum = " << mom[0] << " : " << mom[1] << " : "
+                                     << mom[2]);
 
     // smear the truth particle momentum and position
     Acts::Vector3D dir = mom.normalized();
@@ -183,58 +186,63 @@ FW::FittingAlgorithm<kalman_Fitter_t>::execute(
 
     // perform the fit with KalmanFitter
     auto fittedResult = m_cfg.kFitter.fit(sourceLinks, rStart, kfOptions);
-    ACTS_DEBUG("Finish the fitting.");
-
-    // get the fitted parameters
-    if (fittedResult.fittedParameters) {
-      ACTS_DEBUG("Get the fitted parameters.");
-      auto fittedParameters = fittedResult.fittedParameters.get();
-      auto fittedPos        = fittedParameters.position();
-      auto fittedMom        = fittedParameters.momentum();
-      ACTS_DEBUG("Fitted Position at target = " << fittedPos[0] << " : "
-                                                << fittedPos[1] << " : "
-                                                << fittedPos[2]);
-      ACTS_DEBUG("Fitted Momentum at target = " << fittedMom[0] << " : "
-                                                << fittedMom[1] << " : "
-                                                << fittedMom[2]);
-    } else {
-      ACTS_WARNING("No fittedParameter!");
-    }
+    ACTS_VERBOSE("Finish the fitting.");
+
+    if (fittedResult.ok()) {
+      auto resultValue = fittedResult.value();
+      // get the fitted parameters
+      if (resultValue.fittedParameters) {
+        ACTS_VERBOSE("Get the fitted parameters.");
+        auto fittedParameters = (*fittedResult).fittedParameters.get();
+        auto fittedPos        = fittedParameters.position();
+        auto fittedMom        = fittedParameters.momentum();
+        ACTS_VERBOSE("Fitted Position at target = " << fittedPos[0] << " : "
+                                                    << fittedPos[1] << " : "
+                                                    << fittedPos[2]);
+        ACTS_VERBOSE("Fitted Momentum at target = " << fittedMom[0] << " : "
+                                                    << fittedMom[1] << " : "
+                                                    << fittedMom[2]);
+      } else {
+        ACTS_VERBOSE("No fittedParameter!");
+      }
 
-    // get the fitted states
-    if (!fittedResult.fittedStates.empty()) {
-      ACTS_DEBUG("Get the fitted states.");
-      if (m_cfg.writeTruthTrajectory) {
-        fittedTracks.push_back(fittedResult.fittedStates);
+      // get the fitted states
+      if (!resultValue.fittedStates.empty()) {
+        ACTS_VERBOSE("Get the fitted states.");
+        if (m_cfg.writeTruthTrajectory) {
+          fittedTracks.push_back((*fittedResult).fittedStates);
+        }
+      } else {
+        ACTS_VERBOSE("No fittedStates!");
       }
+
     } else {
-      ACTS_WARNING("No fittedStates!");
+      ACTS_VERBOSE("Fitting failed!");
     }
 
-    // Make sure the fitting is deterministic
-    // auto fittedAgainTrack      = m_cfg.kFitter.fit(measurements, rStart,
-    // rSurface);
-    // ACTS_DEBUG("Finish fitting again");
-    // auto fittedAgainParameters = fittedAgainTrack.fittedParameters.get();
-
     // Emulate trajectories with holes/outliers and refit
     if (m_trajectoryEmulationTool) {
-      ACTS_DEBUG("Emulate trajectory with holes and outliers based on truth "
-                 "trajectory.");
+      ACTS_VERBOSE(
+          "Emulate trajectories with holes and outliers based on the truth "
+          "trajectory.");
       auto emulatedTrajectories
-          = (*m_trajectoryEmulationTool)(context, sourceLinks);
+          = (*m_trajectoryEmulationTool)(context, generator, sourceLinks);
       for (const auto& elTraj : emulatedTrajectories) {
         // perform the fit with KalmanFitter
         auto elFittedResult = m_cfg.kFitter.fit(elTraj, rStart, kfOptions);
-        if (!elFittedResult.fittedStates.empty()) {
-          if (m_cfg.writeEmulateTrajectory) {
-            fittedTracks.push_back(elFittedResult.fittedStates);
+        if (elFittedResult.ok()) {
+          auto elResultValue = elFittedResult.value();
+          if (!elResultValue.fittedStates.empty()) {
+            if (m_cfg.writeEmulateTrajectory) {
+              fittedTracks.push_back((*elFittedResult).fittedStates);
+            }
           }
         }
       }
+      ACTS_VERBOSE("Finish fitting for the emulated trajectories");
     }
 
-    ACTS_DEBUG("Finish processing the track with particle id = " << barcode);
+    ACTS_VERBOSE("Finish processing the track with particle id = " << barcode);
   }
 
   ACTS_DEBUG("There are " << fittedTracks.size()
diff --git a/Algorithms/Fitting/include/ACTFW/Fitting/FittingOptions.hpp b/Algorithms/Fitting/include/ACTFW/Fitting/FittingOptions.hpp
index 4bd676c640fce41fae3ab5c42c7347ca14470426..7e3fe740dfba5960901a81e9f5423eb50c79e637 100644
--- a/Algorithms/Fitting/include/ACTFW/Fitting/FittingOptions.hpp
+++ b/Algorithms/Fitting/include/ACTFW/Fitting/FittingOptions.hpp
@@ -48,9 +48,10 @@ namespace Options {
         "measurement-sigma",
         po::value<read_range>()->multitoken()->default_value({30., 30.}),
         "Gaussian sigma used to smear the truth hit Loc0 [um], Loc1 [um]")(
-        "outlier-chi2-cut",
-        po::value<read_range>()->multitoken()->default_value({10., 5.}),
-        "Chisq cut to determine if measurement is outlier during filtering and "
+        "meas-sig-cut",
+        po::value<read_range>()->multitoken()->default_value({0.01, 0.05}),
+        "p-Value cut to determine if measurement is outlier during filtering "
+        "and "
         "smoothing")("emulate-track", po::value<bool>()->default_value(false))(
         "write-truth-track", po::value<bool>()->default_value(true))(
         "write-emulate-track", po::value<bool>()->default_value(true));
@@ -81,8 +82,8 @@ namespace Options {
     fittingConfig.measurementSigma
         = vm["measurement-sigma"].template as<read_range>();
 
-    fittingConfig.outlierChi2Cut
-        = vm["outlier-chi2-cut"].template as<read_range>();
+    fittingConfig.measurementSignificanceCut
+        = vm["meas-sig-cut"].template as<read_range>();
 
     fittingConfig.emulateTrajectory = vm["emulate-track"].template as<bool>();
     fittingConfig.writeTruthTrajectory
diff --git a/Algorithms/Propagation/include/ACTFW/Propagation/PropagationAlgorithm.ipp b/Algorithms/Propagation/include/ACTFW/Propagation/PropagationAlgorithm.ipp
index e5177352abd8f44d0a6d5ea47524289c062009b7..d0606ba10b04c52f23ab1db73335e61766662457 100644
--- a/Algorithms/Propagation/include/ACTFW/Propagation/PropagationAlgorithm.ipp
+++ b/Algorithms/Propagation/include/ACTFW/Propagation/PropagationAlgorithm.ipp
@@ -66,7 +66,7 @@ PropagationAlgorithm<propagator_t>::executeTest(
   if (m_cfg.mode == 0) {
 
     // The step length logger for testing & end of world aborter
-    using MaterialInteractor = Acts::MaterialInteractor<Acts::fullUpdate>;
+    using MaterialInteractor = Acts::MaterialInteractor<>;
     using SteppingLogger     = Acts::detail::SteppingLogger;
     using DebugOutput        = Acts::detail::DebugOutputActor;
     using EndOfWorld         = Acts::detail::EndOfWorldReached;
@@ -184,15 +184,15 @@ PropagationAlgorithm<propagator_t>::execute(
           context.geoContext, std::move(cov), std::move(pars), surface);
       sPosition = startParameters.position();
       sMomentum = startParameters.momentum();
-      pOutput   = executeTest<Acts::TrackParameters>(context, startParameters);
+      pOutput   = executeTest<Acts::BoundParameters>(context, startParameters);
     } else {
       // execute the test for neeutral particles
       Acts::NeutralBoundParameters neutralParameters(
           context.geoContext, std::move(cov), std::move(pars), surface);
       sPosition = neutralParameters.position();
       sMomentum = neutralParameters.momentum();
-      pOutput
-          = executeTest<Acts::NeutralParameters>(context, neutralParameters);
+      pOutput   = executeTest<Acts::NeutralBoundParameters>(context,
+                                                          neutralParameters);
     }
     // Record the propagator steps
     propagationSteps.push_back(std::move(pOutput.first));
diff --git a/Algorithms/TruthTracking/ACTFW/TruthTracking/TruthVerticesToTracks.cpp b/Algorithms/TruthTracking/ACTFW/TruthTracking/TruthVerticesToTracks.cpp
index 6fb46edc7bf6848d73c4003a01b83f64e197df0f..43777caf7f044ff67d7915b3bdc789dd2dc524d9 100644
--- a/Algorithms/TruthTracking/ACTFW/TruthTracking/TruthVerticesToTracks.cpp
+++ b/Algorithms/TruthTracking/ACTFW/TruthTracking/TruthVerticesToTracks.cpp
@@ -116,7 +116,7 @@ FW::TruthVerticesToTracksAlgorithm::execute(
         double rn_th = gaussDist_angular(rng);
         double rn_qp = gaussDist_qp(rng);
 
-        Acts::TrackParametersBase::ParVector_t smrdParamVec;
+        Acts::CurvilinearParameters::ParVector_t smrdParamVec;
         smrdParamVec << rn_d0, rn_z0, rn_ph, rn_th, rn_qp, 0.;
 
         // Update track parameters
diff --git a/Core/include/ACTFW/Validation/TrajectoryEmulationOptions.hpp b/Core/include/ACTFW/Validation/TrajectoryEmulationOptions.hpp
index b55a8c5ce40f29e12cc6d31b686c4e46f1ab9d77..d77b741c0aa90ac20ebaf170268671c22479edbc 100644
--- a/Core/include/ACTFW/Validation/TrajectoryEmulationOptions.hpp
+++ b/Core/include/ACTFW/Validation/TrajectoryEmulationOptions.hpp
@@ -80,7 +80,7 @@ namespace Options {
     }
 
     // and return the config
-    return trajEmulationToolConfig;
+    return std::move(trajEmulationToolConfig);
   }
 
 }  // namespace Options
diff --git a/Core/include/ACTFW/Validation/TrajectoryEmulationTool.hpp b/Core/include/ACTFW/Validation/TrajectoryEmulationTool.hpp
index 2bfaae409f8443f048cd655ded63a18a02ecaf04..488e096b8b171f8df44fac6872ecc26c170082f0 100644
--- a/Core/include/ACTFW/Validation/TrajectoryEmulationTool.hpp
+++ b/Core/include/ACTFW/Validation/TrajectoryEmulationTool.hpp
@@ -12,6 +12,7 @@
 #include <map>
 #include <string>
 
+#include <Acts/Utilities/Units.hpp>
 #include "ACTFW/EventData/Barcode.hpp"
 #include "ACTFW/EventData/SimHit.hpp"
 #include "ACTFW/EventData/SimParticle.hpp"
@@ -25,12 +26,12 @@ namespace FW {
 // Tools to emulate outliers and holes on truth trajectory
 class TrajectoryEmulationTool
 {
+public:
   using Identifier            = Data::SimSourceLink;
   using SourceLinks           = std::vector<Data::SimSourceLink>;
   using SourceLinksVector     = std::vector<std::vector<Data::SimSourceLink>>;
   using MultiplicityGenerator = std::function<size_t(RandomEngine&)>;
 
-public:
   /// @brief The nested configuration struct
   struct Config
   {
@@ -40,8 +41,6 @@ public:
         = nullptr;  ///< generator for number of outliers on emulated track
     MultiplicityGenerator holeMultiplicity
         = nullptr;  ///< generator for number of holes on emulated track
-    std::shared_ptr<RandomNumbers> randomNumbers
-        = nullptr;  ///< random number service
   };
 
   /// Constructor
@@ -52,10 +51,12 @@ public:
                           Acts::Logging::Level level = Acts::Logging::INFO);
 
   /// @brief emulate trajectories with outliers given a truth trajectory
+  /// @param rng is the RandomEngine from the algorithm where this tool is used
   /// @param truthSourceLinks is the truth trajectory
   /// @return a vector of emulated trajectory
   SourceLinksVector
   operator()(const AlgorithmContext& ctx,
+             RandomEngine&           rng,
              const SourceLinks&      truthSourceLinks) const;
 
 private:
diff --git a/Core/src/Validation/EffPlotTool.cpp b/Core/src/Validation/EffPlotTool.cpp
index 809e9880498960c424c9bdb37a0c05dee2d2f705..13d9b9803964cdff2a36061c96110ad7ec3f26cb 100644
--- a/Core/src/Validation/EffPlotTool.cpp
+++ b/Core/src/Validation/EffPlotTool.cpp
@@ -65,8 +65,8 @@ FW::EffPlotTool::fill(EffPlotTool::EffPlotCache& effPlotCache,
   for (auto& state : trajectory) {
     if (state.parameter.smoothed) nSmoothed++;
   }
-  ACTS_DEBUG("There are " << trajectory.size() << " states in total and "
-                          << nSmoothed << " of them are processed.");
+  ACTS_VERBOSE("There are " << trajectory.size() << " states in total and "
+                            << nSmoothed << " of them are processed.");
 
   Acts::Vector3D truthMom = truthParticle.momentum();
 
diff --git a/Core/src/Validation/TrajectoryEmulationTool.cpp b/Core/src/Validation/TrajectoryEmulationTool.cpp
index bad6db069dbd51bc92fa1b6d0a0606dd2e9dd828..17ec89f46fd9dad60dbe5586773c35a22c59f5dd 100644
--- a/Core/src/Validation/TrajectoryEmulationTool.cpp
+++ b/Core/src/Validation/TrajectoryEmulationTool.cpp
@@ -26,20 +26,18 @@ FW::TrajectoryEmulationTool::TrajectoryEmulationTool(
     throw std::invalid_argument(
         "No generator for emulated hole multiplicity is configured!");
   }
-  if (!m_cfg.randomNumbers) {
-    throw std::invalid_argument("Missing random numbers service");
-  }
 }
 
 FW::TrajectoryEmulationTool::SourceLinksVector
 FW::TrajectoryEmulationTool::operator()(
     const AlgorithmContext&                         ctx,
+    FW::RandomEngine&                               rng,
     const FW::TrajectoryEmulationTool::SourceLinks& truthSourceLinks) const
 {
-  // Create a random number generator
-  FW::RandomEngine rng = m_cfg.randomNumbers->spawnGenerator(ctx);
+  // Create an equal 'true' and 'false' distribution
+  std::bernoulli_distribution bnlDist(0.5);
 
-  // lambda to create outliers on a trajectory
+  // Lambda to create outliers on a trajectory
   auto createOutlier =
       [&](const FW::TrajectoryEmulationTool::SourceLinks& sLinks,
           const std::vector<int>                          outlierIndexs) {
@@ -72,8 +70,8 @@ FW::TrajectoryEmulationTool::operator()(
             cov2D << resX * resX, 0., 0., resY * resY;
 
             // smear is based on 10*resolution
-            double dx = resX * 10;
-            double dy = resY * 10;
+            double dx = resX * 10 * (bnlDist(rng) ? 1 : -1);
+            double dy = resY * 10 * (bnlDist(rng) ? 1 : -1);
 
             // move a ,LOC_0, LOC_1 measurement
             // make source link with smeared hit
@@ -95,7 +93,7 @@ FW::TrajectoryEmulationTool::operator()(
         return emulatedTraj;
       };
 
-  // lambda to create holes on a trajectory
+  // Lambda to create holes on a trajectory
   auto createHole = [](const FW::TrajectoryEmulationTool::SourceLinks& sLinks,
                        const std::vector<int> holeIndexs) {
     FW::TrajectoryEmulationTool::SourceLinks emulatedTraj = {};
@@ -117,8 +115,10 @@ FW::TrajectoryEmulationTool::operator()(
                                                   truthSourceLinks.size() - 1);
 
   FW::TrajectoryEmulationTool::SourceLinksVector emulatedTrajectories = {};
-  // create trajectories with outliers and holes
-  for (size_t iTraj = m_cfg.trajectoryMultiplicity(rng); 0 < iTraj; --iTraj) {
+  // Create trajectories with outliers and holes
+  size_t numTraj = m_cfg.trajectoryMultiplicity(rng);
+  ACTS_VERBOSE("Attempt to emulate " << numTraj << " trajectories.");
+  for (size_t iTraj = numTraj; 0 < iTraj; --iTraj) {
     // 1) determine number of outliers and holes
     size_t attemptedNumOutliers = m_cfg.outlierMultiplicity(rng);
     size_t numOutliers          = attemptedNumOutliers < truthSourceLinks.size()
@@ -129,6 +129,9 @@ FW::TrajectoryEmulationTool::operator()(
     size_t numHoles
         = attemptedNumHoles < truthSourceLinks.size() ? attemptedNumHoles : 0;
     if (numHoles == 0) continue;
+    ACTS_VERBOSE("Attempt to create " << numOutliers << " outliers and "
+                                      << numHoles
+                                      << " holes on trajectory: " << iTraj);
 
     // 2) determine the locations of the outliers and holes
     // vector to store the index of outliers and holes
@@ -147,5 +150,9 @@ FW::TrajectoryEmulationTool::operator()(
     // 4) push the trajectory
     emulatedTrajectories.push_back(traj);
   }
+  ACTS_VERBOSE(
+      emulatedTrajectories.size()
+      << " trajectories with holes/outliers are emulated successfully.");
+
   return emulatedTrajectories;
 }
diff --git a/Examples/Common/src/detail/FatrasSimulationBase.hpp b/Examples/Common/src/detail/FatrasSimulationBase.hpp
index ece4f35c7fb9565bfe52155e45641a301f6d5532..76253441f3ff5cbb13b4b55b1c9fa6c8365c63f7 100644
--- a/Examples/Common/src/detail/FatrasSimulationBase.hpp
+++ b/Examples/Common/src/detail/FatrasSimulationBase.hpp
@@ -110,6 +110,18 @@ struct SurfaceSelector
   }
 };
 
+/// The selector
+struct Selector
+{
+  /// call operator
+  template <typename detector_t, typename particle_t>
+  bool
+  operator()(const detector_t, const particle_t&) const
+  {
+    return true;
+  }
+};
+
 /// @brief Simulation setup for the FatrasAlgorithm
 ///
 /// @tparam bfield_t Type of the bfield for the simulation to be set up
diff --git a/Examples/Common/src/detail/FittingBase.hpp b/Examples/Common/src/detail/FittingBase.hpp
index c27dd48f6a7d431f0434925c0b0ad7b9b17b89de..faec8b255d025eb502ccd1f7513db1a35b234dee 100644
--- a/Examples/Common/src/detail/FittingBase.hpp
+++ b/Examples/Common/src/detail/FittingBase.hpp
@@ -79,7 +79,6 @@ setupFittingAlgorithm(bfield_t                                      fieldMap,
   // Config the trajectory emulation tool
   FW::TrajectoryEmulationTool::Config trajEmulationToolConfig
       = FW::Options::readTrajectoryEmulationConfig(vm);
-  trajEmulationToolConfig.randomNumbers = randomNumberSvc;
 
   // Config the fitting algorithm
   typename FittingAlgorithm::Config fittingConfig
diff --git a/Plugins/Root/src/RootTrajectoryWriter.cpp b/Plugins/Root/src/RootTrajectoryWriter.cpp
index aa2ce7450c3322b37b61087edfe7cc39c29b12b0..12dd4b1144fd30b83e8336bb1d0dad7b381e20b2 100644
--- a/Plugins/Root/src/RootTrajectoryWriter.cpp
+++ b/Plugins/Root/src/RootTrajectoryWriter.cpp
@@ -261,7 +261,7 @@ FW::Root::RootTrajectoryWriter::writeT(const AlgorithmContext& ctx,
 
     // find the truth particle via the barcode
     if (particles.find(m_t_barcode) != particles.end()) {
-      ACTS_DEBUG("Find the truth particle with barcode = " << m_t_barcode);
+      ACTS_VERBOSE("Find the truth particle with barcode = " << m_t_barcode);
       auto particle = particles.find(m_t_barcode)->second;
       // get the truth particle info at vertex
       Acts::Vector3D truthPos = particle.position();
@@ -374,7 +374,7 @@ FW::Root::RootTrajectoryWriter::writeT(const AlgorithmContext& ctx,
       m_chi2 = state.parameter.chi2;
 
       // get the predicted parameter
-      ACTS_DEBUG("Get the predicted parameter.");
+      ACTS_VERBOSE("Get the predicted parameter.");
       bool predicted = false;
       if (state.parameter.predicted) {
         predicted = true;
@@ -480,7 +480,7 @@ FW::Root::RootTrajectoryWriter::writeT(const AlgorithmContext& ctx,
       }
 
       // get the filtered parameter
-      ACTS_DEBUG("Get the filtered parameter.");
+      ACTS_VERBOSE("Get the filtered parameter.");
       bool filtered = false;
       if (state.parameter.filtered) {
         filtered = true;
@@ -568,7 +568,7 @@ FW::Root::RootTrajectoryWriter::writeT(const AlgorithmContext& ctx,
       }
 
       // get the smoothed parameter
-      ACTS_DEBUG("Get the smoothed parameter.");
+      ACTS_VERBOSE("Get the smoothed parameter.");
       bool smoothed = false;
       if (state.parameter.smoothed) {
         smoothed = true;
diff --git a/Plugins/Root/src/RootVertexAndTracksReader.cpp b/Plugins/Root/src/RootVertexAndTracksReader.cpp
index eee00c7d72bba761887d7f2597870fcc8807328a..dc7afdfb8d7cf6f1f8dc891a1189b1e9bc2a70f1 100644
--- a/Plugins/Root/src/RootVertexAndTracksReader.cpp
+++ b/Plugins/Root/src/RootVertexAndTracksReader.cpp
@@ -105,7 +105,7 @@ FW::Root::RootVertexAndTracksReader::read(const FW::AlgorithmContext& context)
           // Take only tracks that belong to current vertex
           if ((*m_ptrVtxID)[trkId] == idx) {
             // Get track parameter
-            Acts::TrackParametersBase::ParVector_t newTrackParams;
+            Acts::BoundParameters::ParVector_t newTrackParams;
             newTrackParams << (*m_ptrD0)[trkId], (*m_ptrZ0)[trkId],
                 (*m_ptrPhi)[trkId], (*m_ptrTheta)[trkId], (*m_ptrQP)[trkId],
                 (*m_ptrTime)[trkId];
diff --git a/external/acts-core b/external/acts-core
index 407443630172f7d8fc709bf629bb38a0bf682a1e..dcb5cd287e8cdf67fe392ef34309b3044b66f157 160000
--- a/external/acts-core
+++ b/external/acts-core
@@ -1 +1 @@
-Subproject commit 407443630172f7d8fc709bf629bb38a0bf682a1e
+Subproject commit dcb5cd287e8cdf67fe392ef34309b3044b66f157