feat: Allow propagator initialization to fail

Core/include/Acts/Navigation/DetectorNavigator.hpp

@@ -116,9 +116,9 @@ class DetectorNavigator {
     return state.navigationBreak;
   }
 
-  void initialize(State& state, const Vector3& position,
-                  const Vector3& direction,
-                  Direction propagationDirection) const {
+  [[nodiscard]] Result<void> initialize(State& state, const Vector3& position,
+                                        const Vector3& direction,
+                                        Direction propagationDirection) const {
     (void)propagationDirection;
 
     ACTS_VERBOSE(volInfo(state) << posInfo(state, position) << "initialize");
@@ -140,6 +140,8 @@ class DetectorNavigator {
       throw std::invalid_argument("DetectorNavigator: no current volume found");
     }
     updateCandidateSurfaces(state, position);
+
+    return Result<void>::success();
   }
 
   NavigationTarget nextTarget(State& state, const Vector3& position,

Core/include/Acts/Propagator/DirectNavigator.hpp

@@ -20,6 +20,7 @@
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Utilities/Intersection.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "Acts/Utilities/Result.hpp"
 
 #include <limits>
 #include <memory>
@@ -171,9 +172,9 @@ class DirectNavigator {
   /// @param position The start position
   /// @param direction The start direction
   /// @param propagationDirection The propagation direction
-  void initialize(State& state, const Vector3& position,
-                  const Vector3& direction,
-                  Direction propagationDirection) const {
+  [[nodiscard]] Result<void> initialize(State& state, const Vector3& position,
+                                        const Vector3& direction,
+                                        Direction propagationDirection) const {
     (void)position;
     (void)direction;
 
@@ -214,6 +215,8 @@ class DirectNavigator {
     }
 
     state.navigationBreak = false;
+
+    return Result<void>::success();
   }
 
   /// @brief Get the next target surface

Core/include/Acts/Propagator/Navigator.hpp

@@ -13,6 +13,7 @@
 #include "Acts/Geometry/TrackingGeometry.hpp"
 #include "Acts/Geometry/TrackingVolume.hpp"
 #include "Acts/Propagator/NavigationTarget.hpp"
+#include "Acts/Propagator/NavigatorError.hpp"
 #include "Acts/Propagator/NavigatorOptions.hpp"
 #include "Acts/Propagator/NavigatorStatistics.hpp"
 #include "Acts/Surfaces/BoundaryTolerance.hpp"
@@ -260,17 +261,19 @@ class Navigator {
     return state.navigationBreak;
   }
 
-  /// @brief Initialize the navigator
+  /// @brief Initialize the navigator state
   ///
-  /// This function initializes the navigator for a new propagation.
+  /// This function initializes the navigator state for a new propagation.
   ///
   /// @param state The navigation state
   /// @param position The start position
   /// @param direction The start direction
   /// @param propagationDirection The propagation direction
-  void initialize(State& state, const Vector3& position,
-                  const Vector3& direction,
-                  Direction propagationDirection) const {
+  ///
+  /// @return Indication if the initialization was successful
+  [[nodiscard]] Result<void> initialize(State& state, const Vector3& position,
+                                        const Vector3& direction,
+                                        Direction propagationDirection) const {
     (void)propagationDirection;
 
     ACTS_VERBOSE(volInfo(state) << "Initialization.");
@@ -326,9 +329,16 @@ class Navigator {
     if (state.currentVolume != nullptr) {
       ACTS_VERBOSE(volInfo(state) << "Start volume resolved "
                                   << state.currentVolume->geometryId());
-      assert(state.currentVolume->inside(position,
-                                         state.options.surfaceTolerance) &&
-             "We did not end up inside the volume.");
+
+      if (!state.currentVolume->inside(position,
+                                       state.options.surfaceTolerance)) {
+        ACTS_DEBUG(
+            volInfo(state)
+            << "We did not end up inside the expected volume. position = "
+            << position.transpose());
+
+        return Result<void>::failure(NavigatorError::NotInsideExpectedVolume);
+      }
     }
     if (state.currentLayer != nullptr) {
       ACTS_VERBOSE(volInfo(state) << "Start layer resolved "
@@ -337,12 +347,21 @@ class Navigator {
     if (state.currentSurface != nullptr) {
       ACTS_VERBOSE(volInfo(state) << "Start surface resolved "
                                   << state.currentSurface->geometryId());
-      assert(state.currentSurface->isOnSurface(
-                 state.options.geoContext, position, direction,
-                 BoundaryTolerance::Infinite(),
-                 state.options.surfaceTolerance) &&
-             "Stepper not on surface");
+
+      if (!state.currentSurface->isOnSurface(
+              state.options.geoContext, position, direction,
+              BoundaryTolerance::Infinite(), state.options.surfaceTolerance)) {
+        ACTS_DEBUG(volInfo(state)
+                   << "We did not end up on the expected surface. surface = "
+                   << state.currentSurface->geometryId()
+                   << " position = " << position.transpose()
+                   << " direction = " << direction.transpose());
+
+        return Result<void>::failure(NavigatorError::NotOnExpectedSurface);
+      }
     }
+
+    return Result<void>::success();
   }
 
   /// @brief Get the next target surface

Core/include/Acts/Propagator/NavigatorError.hpp

@@ -0,0 +1,30 @@
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 CERN for the benefit of the ACTS project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include <system_error>
+#include <type_traits>
+
+namespace Acts {
+
+enum class NavigatorError {
+  // ensure all values are non-zero
+  NotInsideExpectedVolume = 1,
+  NotOnExpectedSurface = 2,
+};
+
+std::error_code make_error_code(Acts::NavigatorError e);
+
+}  // namespace Acts
+
+// register with STL
+namespace std {
+template <>
+struct is_error_code_enum<Acts::NavigatorError> : std::true_type {};
+}  // namespace std

Core/include/Acts/Propagator/Propagator.hpp

@@ -279,44 +279,51 @@ class Propagator final
   /// This function creates the propagator state object from the initial track
   /// parameters and the propagation options.
   ///
-  /// @note This will also initialize the state
-  ///
-  /// @tparam parameters_t Type of initial track parameters to propagate
   /// @tparam propagator_options_t Type of the propagator options
   /// @tparam path_aborter_t The path aborter type to be added
   ///
-  /// @param [in] start Initial track parameters to propagate
   /// @param [in] options Propagation options
   ///
   /// @return Propagator state object
-  template <typename parameters_t, typename propagator_options_t,
+  template <typename propagator_options_t,
             typename path_aborter_t = PathLimitReached>
-  auto makeState(const parameters_t& start,
-                 const propagator_options_t& options) const;
+  auto makeState(const propagator_options_t& options) const;
 
   /// @brief Builds the propagator state object
   ///
   /// This function creates the propagator state object from the initial track
   /// parameters, the target surface, and the propagation options.
   ///
-  /// @note This will also initialize the state
-  ///
-  /// @tparam parameters_t Type of initial track parameters to propagate
   /// @tparam propagator_options_t Type of the propagator options
   /// @tparam target_aborter_t The target aborter type to be added
   /// @tparam path_aborter_t The path aborter type to be added
   ///
-  /// @param [in] start Initial track parameters to propagate
   /// @param [in] target Target surface of to propagate to
   /// @param [in] options Propagation options
   ///
   /// @return Propagator state object
-  template <typename parameters_t, typename propagator_options_t,
+  template <typename propagator_options_t,
             typename target_aborter_t = SurfaceReached,
             typename path_aborter_t = PathLimitReached>
-  auto makeState(const parameters_t& start, const Surface& target,
+  auto makeState(const Surface& target,
                  const propagator_options_t& options) const;
 
+  /// @brief Initialize the propagator state
+  ///
+  /// This function initializes the propagator state for a new propagation.
+  ///
+  /// @tparam propagator_state_t Type of the propagator state object
+  /// @tparam path_aborter_t The path aborter type to be added
+  ///
+  /// @param [in,out] state The propagator state object
+  /// @param [in] start Initial track parameters to propagate
+  ///
+  /// @return Indication if the initialization was successful
+  template <typename propagator_state_t, typename parameters_t,
+            typename path_aborter_t = PathLimitReached>
+  [[nodiscard]] Result<void> initialize(propagator_state_t& state,
+                                        const parameters_t& start) const;
+
   /// @brief Propagate track parameters
   ///
   /// This function performs the propagation of the track parameters according
@@ -386,10 +393,6 @@ class Propagator final
  private:
   const Logger& logger() const { return *m_logger; }
 
-  template <typename propagator_state_t, typename parameters_t,
-            typename path_aborter_t>
-  void initialize(propagator_state_t& state, const parameters_t& start) const;
-
   template <typename propagator_state_t, typename result_t>
   void moveStateToResult(propagator_state_t& state, result_t& result) const;