docs: typos and and grammar missed by the CI (#2517)

Just random things I collected over the last months while reading some code.

Alignment/include/ActsAlignment/Kernel/Alignment.hpp

@@ -74,7 +74,7 @@ struct AlignmentOptions {
   // The detector elements to be aligned
   std::vector<Acts::DetectorElementBase*> alignedDetElements;
 
-  // The alignment tolerance to determine if the alignment is coveraged
+  // The alignment tolerance to determine if the alignment is covered
   double averageChi2ONdfCutOff = 0.5;
 
   // The delta of average chi2/ndf within a couple of iterations to determine if
@@ -101,7 +101,7 @@ struct AlignmentResult {
   // The covariance of alignment parameters
   Acts::ActsDynamicMatrix alignmentCovariance;
 
-  // The avarage chi2/ndf (ndf is the measurement dim)
+  // The average chi2/ndf (ndf is the measurement dim)
   double averageChi2ONdf = std::numeric_limits<double>::max();
 
   // The delta chi2

Alignment/include/ActsAlignment/Kernel/Alignment.ipp

@@ -59,14 +59,14 @@ void ActsAlignment::Alignment<fitter_t>::calculateAlignmentParameters(
     const fit_options_t& fitOptions,
     ActsAlignment::AlignmentResult& alignResult,
     const ActsAlignment::AlignmentMask& alignMask) const {
-  // The number of trajectories must be eual to the number of starting
+  // The number of trajectories must be equal to the number of starting
   // parameters
   assert(trajectoryCollection.size() == startParametersCollection.size());
 
   // The total alignment degree of freedom
   alignResult.alignmentDof =
       alignResult.idxedAlignSurfaces.size() * Acts::eAlignmentSize;
-  // Initialize derivative of chi2 w.r.t. aligment parameters for all tracks
+  // Initialize derivative of chi2 w.r.t. alignment parameters for all tracks
   Acts::ActsDynamicVector sumChi2Derivative =
       Acts::ActsDynamicVector::Zero(alignResult.alignmentDof);
   Acts::ActsDynamicMatrix sumChi2SecondDerivative =
@@ -97,7 +97,7 @@ void ActsAlignment::Alignment<fitter_t>::calculateAlignmentParameters(
     const auto& alignState = evaluateRes.value();
     for (const auto& [rowSurface, rows] : alignState.alignedSurfaces) {
       const auto& [dstRow, srcRow] = rows;
-      // Fill the results into full chi2 derivative matrixs
+      // Fill the results into full chi2 derivative matrix
       sumChi2Derivative.segment<Acts::eAlignmentSize>(dstRow *
                                                       Acts::eAlignmentSize) +=
           alignState.alignmentToChi2Derivative.segment(
@@ -262,7 +262,7 @@ ActsAlignment::Alignment<fitter_t>::align(
       if (std::abs(recentChi2ONdf.front() - alignResult.averageChi2ONdf) <=
           alignOptions.deltaAverageChi2ONdfCutOff.second) {
         ACTS_INFO(
-            "Alignment has converaged with change of chi2/ndf < "
+            "Alignment has converged with change of chi2/ndf < "
             << alignOptions.deltaAverageChi2ONdfCutOff.second << " in the last "
             << alignOptions.deltaAverageChi2ONdfCutOff.first << " iterations"
             << " after " << iIter << " iteration(s)");
@@ -273,7 +273,7 @@ ActsAlignment::Alignment<fitter_t>::align(
     }
     // 2. or the average chi2/ndf (is this correct?)
     if (alignResult.averageChi2ONdf <= alignOptions.averageChi2ONdfCutOff) {
-      ACTS_INFO("Alignment has converaged with average chi2/ndf < "
+      ACTS_INFO("Alignment has converged with average chi2/ndf < "
                 << alignOptions.averageChi2ONdfCutOff << " after " << iIter
                 << " iteration(s)");
       converged = true;
@@ -320,7 +320,7 @@ ActsAlignment::Alignment<fitter_t>::align(
       ACTS_VERBOSE("Center (cenX, cenY, cenZ) = " << translation.transpose());
       ACTS_VERBOSE(
           "Euler angles (rotZ, rotY, rotX) = " << rotAngles.transpose());
-      ACTS_VERBOSE("Rotation marix = \n" << rotation);
+      ACTS_VERBOSE("Rotation matrix = \n" << rotation);
     }
   } else {
     ACTS_DEBUG("Alignment parameters is not updated.");

Alignment/include/ActsAlignment/Kernel/detail/AlignmentEngine.hpp

@@ -149,7 +149,7 @@ TrackAlignmentState trackAlignmentState(
       alignState.alignedSurfaces[surface].first = it->second;
       nAlignSurfaces++;
     }
-    // Rember the index of the state within the trajectory and whether it's
+    // Remember the index of the state within the trajectory and whether it's
     // alignable
     measurementStates.push_back({ts.index(), isAlignable});
     // Add up measurement dimension
@@ -167,7 +167,7 @@ TrackAlignmentState trackAlignmentState(
   // Dimension of global track parameters (from only measurement states)
   alignState.trackParametersDim = eBoundSize * measurementStates.size();
 
-  // Initialize the alignment matrixs with components from the measurement
+  // Initialize the alignment matrices with components from the measurement
   // states
   // The measurement covariance
   alignState.measurementCovariance = ActsDynamicMatrix::Zero(
@@ -190,7 +190,7 @@ TrackAlignmentState trackAlignmentState(
   // should be same as eBoundSize * nSmoothedStates
   const auto& [sourceTrackParamsCov, stateRowIndices] = globalTrackParamsCov;
 
-  // Loop over the measurement states to fill those alignment matrixs
+  // Loop over the measurement states to fill those alignment matrices
   // This is done in reverse order
   size_t iMeasurement = alignState.measurementDim;
   size_t iParams = alignState.trackParametersDim;
@@ -227,7 +227,7 @@ TrackAlignmentState trackAlignmentState(
       // The direction
       const Vector3 direction = freeParams.segment<3>(eFreeDir0);
       // The derivative of free parameters w.r.t. path length. @note Here, we
-      // assumes a linear track model, i.e. negecting the change of track
+      // assume a linear track model, i.e. neglecting the change of track
       // direction. Otherwise, we need to know the magnetic field at the free
       // parameters
       FreeVector pathDerivative = FreeVector::Zero();

Core/include/Acts/Clusterization/Clusterization.hpp

@@ -16,8 +16,8 @@ namespace Acts::Ccl {
 using Label = int;
 constexpr Label NO_LABEL = 0;
 
-// When looking for a cell connected to a reference cluster, the the
-// code always loops backward, starting from the reference cell. Since
+// When looking for a cell connected to a reference cluster, the code
+// always loops backward, starting from the reference cell. Since
 // the cells are globally sorted column-wise, the connection function
 // can therefore tell when the search should be stopped.
 enum class ConnectResult {

Core/include/Acts/Definitions/TrackParametrization.hpp

@@ -22,8 +22,8 @@
 namespace Acts {
 
 // Note:
-// The named indices are use to access raw data vectors and matrices at the
-// lowest level. Since the interpretation of some of the components, e.g. local
+// The named indices are used to access raw data vectors and matrices at the
+// lowest level. Since the interpretation of some components, e.g. local
 // position and the inverse-momentum-like component, depend on additional
 // information the names have some ambiguity. This can only be resolved at a
 // higher logical level and no attempt is made to resolve it here.

Core/include/Acts/Digitization/DigitizationCell.hpp

@@ -18,13 +18,13 @@ struct DigitizationCell final {
   size_t channel1 = 1;
   float data = 0.;
 
-  // connstruct them
+  // construct them
   DigitizationCell(size_t ch0, size_t ch1, float d = 0.)
       : channel0(ch0), channel1(ch1), data(d) {}
 
   /// To merge cells in case they are at the same position
   /// @param dc the cell to be added to the current cell
-  /// @param analogueReadout flag indicating if we have analgue readout
+  /// @param analogueReadout flag indicating if we have analogue readout
   /// @note this function is needed because possible derived classes may
   /// calculate the energy deposit differently. Furthermore this allows to apply
   /// an energy cut, because the energy deposit can also be stored for digital

Core/include/Acts/EventData/Measurement.hpp

@@ -41,7 +41,7 @@ namespace Acts {
 /// This means either, that there needs to be an additional variable type or
 /// that a pointer to a base object is stored (requiring a `dynamic_cast` later
 /// on). Both variants add additional complications. Since the geometry object
-/// is not required anyways (as discussed above), not storing it removes all
+/// is not required anyway (as discussed above), not storing it removes all
 /// these complications altogether.
 template <typename indices_t, size_t kSize>
 class Measurement {

Core/include/Acts/EventData/TrackProxy.hpp

@@ -599,7 +599,7 @@ class TrackProxy {
 
   /// Return a mutable reference to the number of degrees of freedom for the
   /// track. Mutable version
-  /// @return The the number of degrees of freedom
+  /// @return The number of degrees of freedom
   template <bool RO = ReadOnly, typename = std::enable_if_t<!RO>>
   unsigned int& nDoF() {
     return component<unsigned int>(hashString("ndf"));
@@ -627,7 +627,7 @@ class TrackProxy {
 
   /// Copy the content of another track proxy into this one
   /// @tparam track_proxy_t the other track proxy's type
-  /// @param other The the track proxy
+  /// @param other The track proxy
   /// @param copyTrackStates Copy the track state sequence from @p other
   template <typename track_proxy_t, bool RO = ReadOnly,
             typename = std::enable_if_t<!RO>>

Core/include/Acts/Geometry/CylinderVolumeBuilder.hpp

@@ -418,7 +418,7 @@ struct WrappingConfig {
       sl << "New container built with       configuration: "
          << containerVolumeConfig.toString() << '\n';
     }
-    // go through the new new ones first
+    // go through the new ones first
     if (nVolumeConfig) {
       sl << " - n: Negative Endcap, current configuration: "
          << nVolumeConfig.toString() << '\n';
@@ -476,7 +476,7 @@ class CylinderVolumeBuilder : public ITrackingVolumeBuilder {
   struct Config {
     /// The tracking volume helper for construction
     std::shared_ptr<const ITrackingVolumeHelper> trackingVolumeHelper = nullptr;
-    /// The string based indenfication
+    /// The string based identification
     std::string volumeName = "";
     /// The world material
     std::shared_ptr<const IVolumeMaterial> volumeMaterial = nullptr;

Core/include/Acts/Geometry/ITrackingVolumeArrayCreator.hpp

@@ -52,7 +52,7 @@ class ITrackingVolumeArrayCreator {
   /// @param vols are the TrackingVolumes ordered in a tracker
   /// @param bVal is the binning value for the volume binning
   ///
-  /// @return sahred pointer to a new TrackingVolumeArray
+  /// @return shared pointer to a new TrackingVolumeArray
   virtual std::shared_ptr<const TrackingVolumeArray> trackingVolumeArray(
       const GeometryContext& gctx, const TrackingVolumeVector& vols,
       BinningValue bVal) const = 0;

Core/include/Acts/Geometry/LayerCreator.hpp

@@ -34,7 +34,7 @@ using MutableLayerPtr = std::shared_ptr<Layer>;
 
 /// @class LayerCreator
 ///
-/// The LayerCreator is able to build cylinde,r disc layers or plane layers from
+/// The LayerCreator is able to build cylinder disc layers or plane layers from
 /// detector elements
 ///
 class LayerCreator {
@@ -46,9 +46,9 @@ class LayerCreator {
   struct Config {
     /// surface array helper
     std::shared_ptr<const SurfaceArrayCreator> surfaceArrayCreator = nullptr;
-    /// cylinder module z tolerance : it counts at same z, if ...
+    /// cylinder module z tolerance: it counts as same z, if ...
     double cylinderZtolerance{10.};
-    /// cylinder module phi tolerance : it counts at same phi, if ...
+    /// cylinder module phi tolerance: it counts as same phi, if ...
     double cylinderPhiTolerance{0.1};
     /// standard constructor
     Config() = default;
@@ -203,7 +203,7 @@ class LayerCreator {
   /// @param newLogger the logger instance
   void setLogger(std::unique_ptr<const Logger> newLogger);
 
-  // associate surfaces contained by this layer to this layer
+  /// associate surfaces contained by this layer to this layer
   void associateSurfacesToLayer(Layer& layer) const;
 
  private:

Core/include/Acts/Material/AccumulatedMaterialSlab.hpp

@@ -54,7 +54,7 @@ class AccumulatedMaterialSlab {
   /// @param useEmptyTrack indicate whether to consider an empty track store
   ///
   /// The material variance can be used to optimised the mapping process as it
-  /// should be inversly proportionnal to the map quality
+  /// should be inversely proportional to the map quality
   void trackVariance(MaterialSlab slabReference, bool useEmptyTrack = false);
 
   /// Add the accumulated material for the current track to the total average.
@@ -88,7 +88,7 @@ class AccumulatedMaterialSlab {
   /// Only contains the information up to the last `.trackVariance(...)` call.
   /// If there have been additional calls to `.accumulate(...)` afterwards, the
   /// information is not part of the total average. The number of tracks is only
-  /// opdated on the call of `.trackAverage(...)`
+  /// updated on the call of `.trackAverage(...)`
   std::pair<float, unsigned int> totalVariance() const;
 
  private:

Core/include/Acts/Navigation/DetectorNavigator.hpp

@@ -141,7 +141,7 @@ class DetectorNavigator {
 
   /// Initialize call - start of propagation
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -379,7 +379,7 @@ class DetectorNavigator {
   /// - attempted volume switch
   /// Target finding by association will not be done again
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object

Core/include/Acts/Propagator/ActionList.hpp

@@ -26,7 +26,7 @@ namespace Acts {
 /// @brief ActionList implementation to be used with the propagator
 ///
 /// This is the ActionList struct that is used in the propagator
-/// to define a list of different actors_t that are eacch
+/// to define a list of different actors_t that are each
 /// executed during the stepping procedure
 template <typename... actors_t>
 struct ActionList : public detail::Extendable<actors_t...> {

Core/include/Acts/Propagator/AtlasStepper.hpp

@@ -28,7 +28,7 @@
 #include <cmath>
 #include <functional>
 
-// This is based original stepper code from the ATLAS RungeKuttePropagagor
+// This is based original stepper code from the ATLAS RungeKuttaPropagator
 namespace Acts {
 
 /// @brief the AtlasStepper implementation for the

Core/include/Acts/Propagator/DirectNavigator.hpp

@@ -190,7 +190,7 @@ class DirectNavigator {
 
   /// @brief Initialize call - start of propagation
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object

Core/include/Acts/Propagator/MaterialInteractor.hpp

@@ -41,7 +41,7 @@ struct MaterialInteractor {
   /// multiple scattering and energy loss is applied  according to the
   /// configuration.
   ///
-  /// @tparam propagator_state_t is the type of Propagagor state
+  /// @tparam propagator_state_t is the type of Propagator state
   /// @tparam stepper_t Type of the stepper of the propagation
   /// @tparam navigator_t Type of the navigator of the propagation
   ///

Core/include/Acts/Propagator/Navigator.hpp

@@ -301,7 +301,7 @@ class Navigator {
 
   /// @brief Initialize call - start of propagation
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -575,9 +575,9 @@ class Navigator {
   /// If there are surfaces to be handled, check if the current
   /// state is on the surface
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
-  /// @tparam navigation_surfaces_t Type of the propagagor
+  /// @tparam navigation_surfaces_t Type of the propagator
   ///
   /// @param [in,out] state is the propagation state object
   /// @param [in] stepper Stepper in use
@@ -622,7 +622,7 @@ class Navigator {
   ///    then return with updated step size
   ///  - if an intersect is not valid, switch to next
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -739,7 +739,7 @@ class Navigator {
   /// If we unpack a surface, the step size is set to the path length
   /// to the first surface, as determined by straight line intersect.
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -912,7 +912,7 @@ class Navigator {
   /// line intersect is found, the boundary surface is skipped.
   /// If we are out of boundary surfaces, the navigation is terminated.
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -1046,7 +1046,7 @@ class Navigator {
   /// - attempted volume switch
   /// Target finding by association will not be done again
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -1117,7 +1117,7 @@ class Navigator {
 
   /// @brief Resolve the surfaces of this layer
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -1200,7 +1200,7 @@ class Navigator {
   /// This initializes the layer candidates when starting
   /// or when entering a new volume
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -1279,7 +1279,7 @@ class Navigator {
   /// This checks if a navigation break had been triggered or navigator
   /// is misconfigured
   ///
-  /// @tparam propagator_state_t The state type of the propagagor
+  /// @tparam propagator_state_t The state type of the propagator
   /// @tparam stepper_t The type of stepper used for the propagation
   ///
   /// @param [in,out] state is the propagation state object
@@ -1292,7 +1292,7 @@ class Navigator {
     if (!m_cfg.trackingGeometry) {
       return true;
     }
-    // turn the navigator into void when you are intructed to do nothing
+    // turn the navigator into void when you are instructed to do nothing
     if (!m_cfg.resolveSensitive && !m_cfg.resolveMaterial &&
         !m_cfg.resolvePassive) {
       return true;