ci and ai feedback

Core/include/Acts/Propagator/AtlasStepper.hpp

@@ -428,11 +428,14 @@ class AtlasStepper {
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param oIntersection [in] The ObjectIntersection to layer, boundary, etc
+  /// @param direction [in] The direction of the propagation
+  /// @param stype [in] The step size type to be set
   /// @param release [in] boolean to trigger step size release
   template <typename object_intersection_t>
   void updateStepSize(State& state, const object_intersection_t& oIntersection,
-                      Direction /*direction*/, ConstrainedStep::Type stype,
+                      Direction direction, ConstrainedStep::Type stype,
                       bool release) const {
+    (void)direction;
     double stepSize = oIntersection.pathLength();
     updateStepSize(state, stepSize, stype, release);
   }

Core/include/Acts/Propagator/EigenStepper.hpp

@@ -264,6 +264,8 @@ class EigenStepper {
   /// @param [in] navDir The navigation direction
   /// @param [in] boundaryTolerance The boundary check for this status update
   /// @param [in] surfaceTolerance Surface tolerance used for intersection
+  /// @param [in] stype The step size type to be set
+  /// @param [in] release Do we release the step size?
   /// @param [in] logger A @c Logger instance
   IntersectionStatus updateSurfaceStatus(
       State& state, const Surface& surface, std::uint8_t index,
@@ -284,11 +286,14 @@ class EigenStepper {
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param oIntersection [in] The ObjectIntersection to layer, boundary, etc
+  /// @param direction [in] The direction of the propagation
+  /// @param stype [in] The step size type to be set
   /// @param release [in] boolean to trigger step size release
   template <typename object_intersection_t>
   void updateStepSize(State& state, const object_intersection_t& oIntersection,
-                      Direction /*direction*/, ConstrainedStep::Type stype,
+                      Direction direction, ConstrainedStep::Type stype,
                       bool release) const {
+    (void)direction;
     double stepSize = oIntersection.pathLength();
     updateStepSize(state, stepSize, stype, release);
   }

Core/include/Acts/Propagator/EigenStepper.ipp

@@ -140,7 +140,7 @@ void Acts::EigenStepper<E>::transportCovarianceToBound(
     State& state, const Surface& surface,
     const FreeToBoundCorrection& freeToBoundCorrection) const {
   detail::transportCovarianceToBound(
-      state.options.geoContext.get(), surface, state.cov, state.jacobian,
+      state.options.geoContext, surface, state.cov, state.jacobian,
       state.jacTransport, state.derivative, state.jacToGlobal, state.pars,
       freeToBoundCorrection);
 }

Core/include/Acts/Propagator/MultiEigenStepperLoop.hpp

@@ -222,7 +222,6 @@ class MultiEigenStepperLoop : public EigenStepper<extension_t> {
     /// @param [in] optionsIn is the options object for the stepper
     /// @param [in] bfield the shared magnetic filed provider
     /// @param [in] multipars The track multi-component track-parameters at start
-    /// @param [in] ssize is the maximum step size
     ///
     /// @note the covariance matrix is copied when needed
     State(const Options& optionsIn,
@@ -505,6 +504,8 @@ class MultiEigenStepperLoop : public EigenStepper<extension_t> {
   /// @param [in] navDir The navigation direction
   /// @param [in] boundaryTolerance The boundary check for this status update
   /// @param [in] surfaceTolerance Surface tolerance used for intersection
+  /// @param [in] stype The step size type to be set
+  /// @param [in] release Do we release the step size?
   /// @param [in] logger A @c Logger instance
   IntersectionStatus updateSurfaceStatus(
       State& state, const Surface& surface, std::uint8_t index,
@@ -581,7 +582,8 @@ class MultiEigenStepperLoop : public EigenStepper<extension_t> {
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param oIntersection [in] The ObjectIntersection to layer, boundary, etc
-  /// @param direction [in] The propagation direction
+  /// @param direction [in] The direction of the propagation
+  /// @param stype [in] The step size type to be set
   /// @param release [in] boolean to trigger step size release
   template <typename object_intersection_t>
   void updateStepSize(State& state, const object_intersection_t& oIntersection,

Core/include/Acts/Propagator/NavigationTarget.hpp

@@ -37,7 +37,7 @@ struct NavigationTarget {
         surfaceIntersectionIndex(surfaceIntersectionIndex_),
         boundaryTolerance(std::move(boundaryTolerance_)) {}
 
-  bool isNone() const { return surface != nullptr; }
+  bool isNone() const { return surface == nullptr; }
 
  private:
   NavigationTarget() = default;

Core/include/Acts/Propagator/StraightLineStepper.hpp

@@ -225,6 +225,8 @@ class StraightLineStepper {
   /// @param [in] navDir The navigation direction
   /// @param [in] boundaryTolerance The boundary check for this status update
   /// @param [in] surfaceTolerance Surface tolerance used for intersection
+  /// @param [in] stype The step size type
+  /// @param [in] release Do we release the step size?
   /// @param [in] logger A logger instance
   IntersectionStatus updateSurfaceStatus(
       State& state, const Surface& surface, std::uint8_t index,
@@ -243,11 +245,14 @@ class StraightLineStepper {
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param oIntersection [in] The ObjectIntersection to layer, boundary, etc
+  /// @param direction [in] The direction of the propagation
+  /// @param stype [in] The step size type to be set
   /// @param release [in] boolean to trigger step size release
   template <typename object_intersection_t>
   void updateStepSize(State& state, const object_intersection_t& oIntersection,
-                      Direction /*direction*/, ConstrainedStep::Type stype,
+                      Direction direction, ConstrainedStep::Type stype,
                       bool release) const {
+    (void)direction;
     double stepSize = oIntersection.pathLength();
     updateStepSize(state, stepSize, stype, release);
   }

Core/include/Acts/Propagator/SympyStepper.hpp

@@ -54,10 +54,9 @@ class SympyStepper {
   struct State {
     /// Constructor from the initial bound track parameters
     ///
-    /// @param [in] gctx is the context object for the geometry
+    /// @param [in] optionsIn is the configuration of the stepper
     /// @param [in] fieldCacheIn is the cache object for the magnetic field
     /// @param [in] par The track parameters at start
-    /// @param [in] ssize is the maximum step size
     ///
     /// @note the covariance matrix is copied when needed
     State(const Options& optionsIn, MagneticFieldProvider::Cache fieldCacheIn,
@@ -230,6 +229,8 @@ class SympyStepper {
   /// @param [in] navDir The navigation direction
   /// @param [in] boundaryTolerance The boundary check for this status update
   /// @param [in] surfaceTolerance Surface tolerance used for intersection
+  /// @param [in] stype The step size type to be set
+  /// @param [in] release Do we release the step size?
   /// @param [in] logger A @c Logger instance
   IntersectionStatus updateSurfaceStatus(
       State& state, const Surface& surface, std::uint8_t index,
@@ -250,11 +251,14 @@ class SympyStepper {
   ///
   /// @param state [in,out] The stepping state (thread-local cache)
   /// @param oIntersection [in] The ObjectIntersection to layer, boundary, etc
+  /// @param direction [in] The direction of the propagation
+  /// @param stype [in] The step size type to be set
   /// @param release [in] boolean to trigger step size release
   template <typename object_intersection_t>
   void updateStepSize(State& state, const object_intersection_t& oIntersection,
-                      Direction /*direction*/, ConstrainedStep::Type stype,
+                      Direction direction, ConstrainedStep::Type stype,
                       bool release) const {
+    (void)direction;
     double stepSize = oIntersection.pathLength();
     updateStepSize(state, stepSize, stype, release);
   }