refactor: Large GSF refactoring

Core/include/Acts/Propagator/MultiEigenStepperLoop.ipp

@@ -114,15 +114,6 @@ Result<double> MultiEigenStepperLoop<E, R, A>::step(
   const auto& logger = state.options.logger;
   State& stepping = state.stepping;
 
-  // It is not possible to remove components from the vector, since the
-  // GSF actor relies on the fact that the ordering and number of
-  // components does not change
-  auto invalidateComponent = [](auto& cmp) {
-    cmp.status = Intersection3D::Status::missed;
-    cmp.weight = 0.0;
-    cmp.state.pars.template segment<3>(eFreeDir0) = Vector3::Zero();
-  };
-
   // Lambda for reweighting the components
   auto reweight = [](auto& cmps) {
     ActsScalar sumOfWeights = 0.0;
@@ -147,10 +138,11 @@ Result<double> MultiEigenStepperLoop<E, R, A>::step(
         m_stepLimitAfterFirstComponentOnSurface) {
       for (auto& cmp : stepping.components) {
         if (cmp.status != Intersection3D::Status::onSurface) {
-          invalidateComponent(cmp);
+          cmp.status = Intersection3D::Status::missed;
         }
       }
 
+      removeMissedComponents(stepping);
       reweight(stepping.components);
 
       ACTS_VERBOSE("Stepper performed "
@@ -194,12 +186,13 @@ Result<double> MultiEigenStepperLoop<E, R, A>::step(
       accumulatedPathLength += component.weight * results.back()->value();
     } else {
       ++errorSteps;
-      invalidateComponent(component);
+      component.status = Intersection3D::Status::missed;
     }
   }
 
   // Since we have invalidated some components, we need to reweight
   if (errorSteps > 0) {
+    removeMissedComponents(stepping);
     reweight(stepping.components);
   }
 

Core/include/Acts/Propagator/MultiStepperAborters.hpp

@@ -17,6 +17,16 @@ namespace Acts {
 struct MultiStepperSurfaceReached {
   MultiStepperSurfaceReached() = default;
 
+  /// If this is set, we are also happy if the mean of the components is on the
+  /// surface. How the averaging is performed depends on the stepper
+  /// implementation
+  bool averageOnSurface = true;
+
+  /// A configurable tolerance within which distance to the intersection we
+  /// consider the surface as reached. Has no effect if averageOnSurface is
+  /// false
+  double averageOnSurfaceTolerance = 0.2;
+
   /// boolean operator for abort condition without using the result
   ///
   /// @tparam propagator_state_t Type of the propagator state
@@ -40,6 +50,7 @@ struct MultiStepperSurfaceReached {
   template <typename propagator_state_t, typename stepper_t>
   bool operator()(propagator_state_t& state, const stepper_t& stepper,
                   const Surface& targetSurface) const {
+    const auto& logger = state.options.logger;
     bool reached = true;
     const auto oldCurrentSurface = state.navigation.currentSurface;
 
@@ -52,6 +63,22 @@ struct MultiStepperSurfaceReached {
       }
     }
 
+    // However, if mean of all is on surface, we are happy as well
+    if (averageOnSurface) {
+      const auto sIntersection = targetSurface.intersect(
+          state.geoContext, stepper.position(state.stepping),
+          state.stepping.navDir * stepper.direction(state.stepping), true);
+
+      if (sIntersection.intersection.status ==
+              Intersection3D::Status::onSurface or
+          sIntersection.intersection.pathLength < averageOnSurfaceTolerance) {
+        ACTS_VERBOSE("Reached target in average mode");
+        state.navigation.currentSurface = &targetSurface;
+        state.navigation.targetReached = true;
+        return true;
+      }
+    }
+
     // These values are changed by the single component aborters but must be
     // reset if not all components are on the target
     if (!reached) {