refactor: navigator interface

Core/include/Acts/Propagator/AbortList.hpp

@@ -102,11 +102,13 @@ struct AbortList : public detail::Extendable<aborters_t...> {
   /// @param [in,out] state is the state object from the propagator
   /// @param [in] stepper Stepper used for the propagation
   template <typename result_t, typename propagator_state_t, typename stepper_t,
-            typename... Args>
+            typename navigator_t, typename... Args>
   bool operator()(const result_t& result, propagator_state_t& state,
-                  const stepper_t& stepper, Args&&... args) const {
-    return detail::abort_list_impl<aborters_t...>::check(
-        tuple(), result, state, stepper, std::forward<Args>(args)...);
+                  const stepper_t& stepper, const navigator_t& navigator,
+                  Args&&... args) const {
+    using impl = detail::abort_list_impl<aborters_t...>;
+    return impl::check(tuple(), result, state, stepper, navigator,
+                       std::forward<Args>(args)...);
   }
 };
 

Core/include/Acts/Propagator/ActionList.hpp

@@ -80,12 +80,14 @@ struct ActionList : public detail::Extendable<actors_t...> {
   /// @param [in,out] state This is the propagator state object
   /// @param [in] stepper The stepper in use
   /// @param [in,out] result This is the result object from actions
-  template <typename propagator_state_t, typename stepper_t, typename result_t,
-            typename... Args>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t, typename result_t, typename... Args>
   void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  result_t& result, Args&&... args) const {
+                  const navigator_t& navigator, result_t& result,
+                  Args&&... args) const {
     using impl = detail::action_list_impl<actors_t...>;
-    impl::action(tuple(), state, stepper, result, std::forward<Args>(args)...);
+    impl::action(tuple(), state, stepper, navigator, result,
+                 std::forward<Args>(args)...);
   }
 };
 

Core/include/Acts/Propagator/DirectNavigator.hpp

@@ -65,12 +65,15 @@ class DirectNavigator {
     /// Actor operator call
     /// @tparam statet Type of the full propagator state
     /// @tparam stepper_t Type of the stepper
+    /// @tparam navigator_t Type of the navigator
     ///
     /// @param state the entire propagator state
     /// @param r the result of this Actor
-    template <typename propagator_state_t, typename stepper_t>
-    void operator()(propagator_state_t& state, const stepper_t& /*unused*/,
-                    result_type& r, const Logger& /*logger*/) const {
+    template <typename propagator_state_t, typename stepper_t,
+              typename navigator_t>
+    void operator()(propagator_state_t& state, const stepper_t& /*stepper*/,
+                    const navigator_t& /*navigator*/, result_type& r,
+                    const Logger& /*logger*/) const {
       // Only act once
       if (not r.initialized) {
         // Initialize the surface sequence
@@ -81,8 +84,10 @@ class DirectNavigator {
     }
 
     /// Actor operator call - resultless, unused
-    template <typename propagator_state_t, typename stepper_t>
-    void operator()(propagator_state_t& /*unused*/, const stepper_t& /*unused*/,
+    template <typename propagator_state_t, typename stepper_t,
+              typename navigator_t>
+    void operator()(propagator_state_t& /*state*/, const stepper_t& /*stepper*/,
+                    const navigator_t& /*navigator*/,
                     const Logger& /*logger*/) const {}
   };
 

Core/include/Acts/Propagator/EigenStepper.ipp

@@ -11,7 +11,6 @@
 
 template <typename E, typename A>
 Acts::EigenStepper<E, A>::EigenStepper(
-
     std::shared_ptr<const MagneticFieldProvider> bField, double overstepLimit)
     : m_bField(std::move(bField)), m_overstepLimit(overstepLimit) {}
 

Core/include/Acts/Propagator/MaterialInteractor.hpp

@@ -48,9 +48,11 @@ struct MaterialInteractor {
   /// @param stepper The stepper in use
   /// @param result is the mutable result state object
   /// @param logger a logger instance
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  result_type& result, const Logger& logger) const {
+                  const navigator_t& /*navigator*/, result_type& result,
+                  const Logger& logger) const {
     // In case of Volume material update the result of the previous step
     if (recordInteractions && !result.materialInteractions.empty() &&
         result.materialInteractions.back().volume != nullptr &&
@@ -124,7 +126,7 @@ struct MaterialInteractor {
 
   /// Material interaction has no pure observer.
   template <typename propagator_state_t>
-  void operator()(propagator_state_t& /* unused */) const {}
+  void operator()(propagator_state_t& /*state*/) const {}
 
  private:
   /// @brief This function records the material effect

Core/include/Acts/Propagator/MultiStepperAborters.hpp

@@ -31,27 +31,34 @@ struct MultiStepperSurfaceReached {
   ///
   /// @tparam propagator_state_t Type of the propagator state
   /// @tparam stepper_t Type of the stepper
+  /// @tparam navigator_t Type of the navigator
   ///
   /// @param [in,out] state The propagation state object
   /// @param [in] stepper Stepper used for propagation
+  /// @param [in] navigator Navigator used for the progation
   /// @param logger a logger instance
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const Logger& logger) const {
-    return (*this)(state, stepper, *state.navigation.targetSurface, logger);
+                  const navigator_t& navigator, const Logger& logger) const {
+    return (*this)(state, stepper, navigator, *state.navigation.targetSurface,
+                   logger);
   }
 
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
   /// @tparam stepper_t Type of the stepper
+  /// @tparam navigator_t Type of the navigator
   ///
   /// @param [in,out] state The propagation state object
   /// @param [in] stepper Stepper used for the progation
   /// @param [in] targetSurface The target surface
   /// @param logger a logger instance
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   bool operator()(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& /*navigator*/,
                   const Surface& targetSurface, const Logger& logger) const {
     bool reached = true;
     const auto oldCurrentSurface = state.navigation.currentSurface;

Core/include/Acts/Propagator/Navigator.hpp

@@ -105,8 +105,7 @@ struct NavigationOptions {
 /// set to the propagation satate, such that other actors can deal wit it.
 /// This navigation actor thus always needs to run first!
 /// It does two things: it figures out the order of volumes, layers and
-/// surfaces. For each propagation step, the operator() runs, which checks if
-/// the current surface (or layer/volume boundary) is reached.
+/// surfaces.
 ///
 /// The current target surface is the surface pointed to by of the iterators
 /// for the surfaces, layers or volume boundaries.

Core/include/Acts/Propagator/Propagator.ipp

@@ -19,15 +19,16 @@ auto Acts::Propagator<S, N>::propagate_impl(propagator_state_t& state,
   // Navigator initialize state call
   m_navigator.status(state, m_stepper);
   // Pre-Stepping call to the action list
-  state.options.actionList(state, m_stepper, result, logger());
+  state.options.actionList(state, m_stepper, m_navigator, result, logger());
   // assume negative outcome, only set to true later if we actually have
   // a positive outcome.
 
   // start at true, if we don't begin the stepping loop we're fine.
   bool terminatedNormally = true;
 
   // Pre-Stepping: abort condition check
-  if (!state.options.abortList(result, state, m_stepper, logger())) {
+  if (!state.options.abortList(result, state, m_stepper, m_navigator,
+                               logger())) {
     // Pre-Stepping: target setting
     m_navigator.target(state, m_stepper);
     // Stepping loop
@@ -53,8 +54,9 @@ auto Acts::Propagator<S, N>::propagate_impl(propagator_state_t& state,
       // Post-stepping:
       // navigator status call - action list - aborter list - target call
       m_navigator.status(state, m_stepper);
-      state.options.actionList(state, m_stepper, result, logger());
-      if (state.options.abortList(result, state, m_stepper, logger())) {
+      state.options.actionList(state, m_stepper, m_navigator, result, logger());
+      if (state.options.abortList(result, state, m_stepper, m_navigator,
+                                  logger())) {
         terminatedNormally = true;
         break;
       }
@@ -76,7 +78,7 @@ auto Acts::Propagator<S, N>::propagate_impl(propagator_state_t& state,
 
   // Post-stepping call to the action list
   ACTS_VERBOSE("Stepping loop done.");
-  state.options.actionList(state, m_stepper, result, logger());
+  state.options.actionList(state, m_stepper, m_navigator, result, logger());
 
   // return progress flag here, decide on SUCCESS later
   return Result<void>::success();

Core/include/Acts/Propagator/StandardAborters.hpp

@@ -48,12 +48,15 @@ struct PathLimitReached {
   ///
   /// @tparam propagator_state_t Type of the propagator state
   /// @tparam stepper_t Type of the stepper
+  /// @tparam navigator_t Type of the navigator
   ///
   /// @param [in,out] state The propagation state object
   /// @param [in] stepper Stepper used for propagation
   /// @param logger a logger instance
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   bool operator()(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& /*navigator*/,
                   const Logger& logger) const {
     if (state.navigation.targetReached) {
       return true;
@@ -89,27 +92,34 @@ struct SurfaceReached {
   ///
   /// @tparam propagator_state_t Type of the propagator state
   /// @tparam stepper_t Type of the stepper
+  /// @tparam navigator_t Type of the navigator
   ///
   /// @param [in,out] state The propagation state object
   /// @param [in] stepper Stepper used for propagation
+  /// @param [in] navigator Navigator used for propagation
   /// @param logger a logger instance
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   bool operator()(propagator_state_t& state, const stepper_t& stepper,
-                  const Logger& logger) const {
-    return (*this)(state, stepper, *state.navigation.targetSurface, logger);
+                  const navigator_t& navigator, const Logger& logger) const {
+    return (*this)(state, stepper, navigator, *state.navigation.targetSurface,
+                   logger);
   }
 
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
   /// @tparam stepper_t Type of the stepper
+  /// @tparam navigator_t Type of the navigator
   ///
   /// @param [in,out] state The propagation state object
   /// @param [in] stepper Stepper used for the progation
   /// @param [in] targetSurface The target surface
   /// @param logger a logger instance
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   bool operator()(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& /*navigator*/,
                   const Surface& targetSurface, const Logger& logger) const {
     if (state.navigation.targetReached) {
       return true;
@@ -178,8 +188,10 @@ struct EndOfWorldReached {
   /// @tparam propagator_state_t Type of the propagator state
   ///
   /// @param [in,out] state The propagation state object
-  template <typename propagator_state_t, typename stepper_t>
-  bool operator()(propagator_state_t& state, const stepper_t& /*unused*/,
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
+  bool operator()(propagator_state_t& state, const stepper_t& /*stepper*/,
+                  const navigator_t& /*navigator*/,
                   const Logger& /*logger*/) const {
     if (state.navigation.currentVolume != nullptr) {
       return false;
@@ -197,11 +209,14 @@ struct ParticleStopped {
   ///
   /// @tparam propagator_state_t Type of the propagator state
   /// @tparam stepper_t Type of the stepper
+  /// @tparam navigator_t Type of the navigator
   ///
   /// @param [in,out] state The propagation state object
   /// @param [in] stepper The stepper object
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   bool operator()(propagator_state_t& state, const stepper_t& stepper,
+                  const navigator_t& /*navigator*/,
                   const Logger& /*logger*/) const {
     if (stepper.momentum(state.stepping) > 0) {
       return false;

Core/include/Acts/Propagator/SurfaceCollector.hpp

@@ -87,9 +87,11 @@ struct SurfaceCollector {
   /// @param [in] stepper The stepper in use
   /// @param [in,out] result is the mutable result object
   /// @param logger a logger instance
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  result_type& result, const Logger& logger) const {
+                  const navigator_t& /*navigator*/, result_type& result,
+                  const Logger& logger) const {
     // The current surface has been assigned by the navigator
     if (state.navigation.currentSurface &&
         selector(*state.navigation.currentSurface)) {
@@ -108,8 +110,10 @@ struct SurfaceCollector {
 
   /// Pure observer interface
   /// - this does not apply to the surface collector
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   void operator()(propagator_state_t& /*state*/, const stepper_t& /*unused*/,
+                  const navigator_t& /*navigator*/,
                   const Logger& /*logger*/) const {}
 };
 

Core/include/Acts/Propagator/VolumeCollector.hpp

@@ -87,9 +87,11 @@ struct VolumeCollector {
   /// @param [in] stepper The stepper in use
   /// @param [in,out] result is the mutable result object
   /// @param logger the logger object
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  result_type& result, const Logger& logger) const {
+                  const navigator_t& /*navigator*/, result_type& result,
+                  const Logger& logger) const {
     // The current volume has been assigned by the navigator
     if (state.navigation.currentVolume &&
         selector(*state.navigation.currentVolume)) {
@@ -118,8 +120,10 @@ struct VolumeCollector {
 
   /// Pure observer interface
   /// - this does not apply to the volume collector
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   void operator()(propagator_state_t& /*state*/, const stepper_t& /*unused*/,
+                  const navigator_t& /*navigator*/,
                   const Logger& /*logger*/) const {}
 };
 

Core/include/Acts/Propagator/detail/SteppingLogger.hpp

@@ -50,14 +50,17 @@ struct SteppingLogger {
 
   /// SteppingLogger action for the ActionList of the Propagator
   ///
-  /// @tparam stepper_t is the type of the Stepper
   /// @tparam propagator_state_t is the type of Propagator state
+  /// @tparam stepper_t is the type of the Stepper
+  /// @tparam navigator_t is the type of the Navigator
   ///
-  /// @param [in,out] state is the mutable stepper state object
   /// @param [in,out] result is the mutable result object
-  template <typename propagator_state_t, typename stepper_t>
+  /// @param [in,out] state is the mutable stepper state object
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   void operator()(propagator_state_t& state, const stepper_t& stepper,
-                  result_type& result, const Logger& /*logger*/) const {
+                  const navigator_t& /*navigator*/, result_type& result,
+                  const Logger& /*logger*/) const {
     // don't log if you have reached the target
     if (sterile or state.navigation.targetReached) {
       return;
@@ -80,8 +83,10 @@ struct SteppingLogger {
 
   /// Pure observer interface
   /// - this does not apply to the logger
-  template <typename propagator_state_t, typename stepper_t>
+  template <typename propagator_state_t, typename stepper_t,
+            typename navigator_t>
   void operator()(propagator_state_t& /*unused*/, const stepper_t& /*unused*/,
+                  const navigator_t& /*navigator*/,
                   const Logger& /*logger*/) const {}
 };
 

Core/include/Acts/Propagator/detail/VoidPropagatorComponents.hpp

@@ -57,14 +57,6 @@ struct VoidNavigator {
   template <typename propagator_state_t, typename stepper_t>
   void target(propagator_state_t& /*state*/,
               const stepper_t& /*unused*/) const {}
-
-  /// Navigation call - void
-  ///
-  /// @tparam propagator_state_t is the type of Propagatgor state
-  ///
-  /// Empty call, compiler should optimise that
-  template <typename propagator_state_t>
-  void operator()(propagator_state_t& /*state*/) const {}
 };
 
 }  // namespace detail