diff --git a/framework/doc/content/syntax/Limiters/index.md b/framework/doc/content/syntax/Limiters/index.md
index 6875812a85de..a312fac8054f 100644
--- a/framework/doc/content/syntax/Limiters/index.md
+++ b/framework/doc/content/syntax/Limiters/index.md
@@ -94,7 +94,7 @@ TVD, and what the functional form of the flux limiting function $\beta(r)$ is.
 | `SOU`               | 2                 | No  | $r$                                          |
 | `QUICK`             | 2                 | No  | $\frac{3+r}{4}$                              |
 
-## Limiting Process for Incompressible and Weakly-Compressible flow Flow
+## Limiting Process for Incompressible and Weakly-Compressible flow
 
 A full second-order upwind reconstruction is used for incompressible and weakly-compressible solvers. In this reconstruction, the limited quantity at the face is expressed as follows:
 
@@ -112,7 +112,7 @@ where:
 
 Two kinds of limiters are supported: slope-limited and face-value limited. These limiters are defined below.
 
-For slope-limiting, the limiting function $r$ is defined as follows:
+For slope-limiting, the approximate gradient ratio (or flux limiting ratio) $r$ is defined as follows:
 
 \begin{equation}
 r = 2 \frac{\bm{d}_{NC} \cdot (\nabla \bm{\Psi})_C}{\bm{d}_{NC} \cdot (\nabla \bm{\Psi})_f} - 1
@@ -153,8 +153,7 @@ Each of the limiters implemented along with the implementation reference, limiti
 | `Venkatakrishnan` [!citep](venkatakrishnan1993) | Face-Value    | No  | $\frac{2r+1}{r(2r+1)+1}$                                          |
 
 
-To illustrate the performance of the limiters, a dispersion analysis is developed.
-The problem is illustrated in [dispersion].
+To illustrate the performance of the limiters, a dispersion analysis is developedand presented in [dispersion].
 This consists of the advection of a passive scalar in a Cartesian mesh at 45 degrees.
 The exact solution, without numerical diffusion, is a straight line at 45 degrees
 dividing the regions with a scalar concentration of 1 and 0.
diff --git a/framework/include/limiters/Limiter.h b/framework/include/limiters/Limiter.h
index a0e1aed8922e..ae1b3450e796 100644
--- a/framework/include/limiters/Limiter.h
+++ b/framework/include/limiters/Limiter.h
@@ -63,18 +63,16 @@ class Limiter
 {
 public:
   /**
-   * @brief Pure virtual method for computing the flux limiting ratio.
-   *
    * This method computes the flux limiting ratio based on the provided scalar values,
    * gradient vectors, direction vector, maximum and minimum allowable values, and
    * geometric information from the face and cell centroids. It must be overridden
    * by any derived class implementing a specific limiting strategy.
    *
-   * @tparam T The data type of the scalar values and the return type.
-   * @param phi_upwind The scalar value at the upwind location.
-   * @param phi_downwind The scalar value at the downwind location.
-   * @param grad_phi_upwind Pointer to the gradient vector at the upwind location.
-   * @param grad_phi_downwind Pointer to the gradient vector at the downwind location.
+   * @tparam T The data type of the field values and the return type.
+   * @param phi_upwind The field value at the upwind location.
+   * @param phi_downwind The field value at the downwind location.
+   * @param grad_phi_upwind Pointer to the gradient of the field at the upwind location.
+   * @param grad_phi_downwind Pointer to the gradient of the field at the downwind location.
    * @param dCD A constant direction vector representing the direction of the cell face.
    * @param max_value The maximum allowable value.
    * @param min_value The minimum allowable value.
@@ -87,30 +85,6 @@ class Limiter
    * the specific limiting algorithm. Derived classes will provide the actual logic for computing
    * the flux limiting ratio, ensuring that the result adheres to the constraints and properties
    * required by the specific limiting method.
-   *
-   * Here is an example of how a derived class might implement this method:
-   *
-   * @example
-   * @code
-   * class MyLimiter : public Limiter<Real>
-   * {
-   * public:
-   *     Real limit(const Real & phi_upwind,
-   *                const Real & phi_downwind,
-   *                const VectorValue<Real> * grad_phi_upwind,
-   *                const VectorValue<Real> * grad_phi_downwind,
-   *                const RealVectorValue & dCD,
-   *                const Real & max_value,
-   *                const Real & min_value,
-   *                const FaceInfo * fi,
-   *                const bool & fi_elem_is_upwind) const override
-   *     {
-   *         // Implementation of the specific limiting algorithm.
-   *         Real ratio = ... // Compute the ratio.
-   *         return ratio; // Return the computed ratio.
-   *     }
-   * };
-   * @endcode
    */
   virtual T limit(const T & phi_upwind,
                   const T & phi_downwind,
@@ -125,35 +99,12 @@ class Limiter
   virtual InterpMethod interpMethod() const = 0;
 
   /**
-   * @brief Functor for applying simplified slope limiting.
-   *
-   * This function applies the limiter by invoking the `limit` method with the provided parameters.
-   * It acts as a functor, enabling objects of the derived `Limiter` class to be used as if they
-   * were functions.
-   *
-   * @tparam T The data type of the scalar values and the return type.
-   * @param phi_upwind The scalar value at the upwind location.
-   * @param phi_downwind The scalar value at the downwind location.
-   * @param grad_phi_upwind Pointer to the gradient vector at the upwind location.
+   * @tparam T The data type of the field values and the return type.
+   * @param phi_upwind The field value at the upwind location.
+   * @param phi_downwind The field value at the downwind location.
+   * @param grad_phi_upwind Pointer to the gradient of the field value at the upwind location.
    * @param dCD A constant direction vector representing the direction of the cell face.
    * @return The computed limited value, ensuring it is within the range [0, 2].
-   *
-   * This method performs the following steps:
-   * 1. Calls the `limit` method with the provided scalar values, the upwind gradient vector, and
-   * the direction vector.
-   * 2. Ensures the result is within the range [0, 2] by using `std::max` and `std::min`.
-   * 3. Returns the computed limited value.
-   *
-   * @example
-   * @code
-   * Limiter<Real> * myLimiter = ... // Assume this is properly initialized
-   * Real phi_upwind = 2.0;
-   * Real phi_downwind = 1.5;
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * FaceInfo * fi = ... // Assume this is properly initialized
-   * Real result = (*myLimiter)(phi_upwind, phi_downwind, &grad_upwind, dCD);
-   * @endcode
    */
   T operator()(const T & phi_upwind,
                const T & phi_downwind,
@@ -174,17 +125,11 @@ class Limiter
   }
 
   /**
-   * @brief Functor for applying general slope limiter.
-   *
-   * This function applies the slope limiter by invoking the `limit` method with the provided
-   * parameters. It acts as a functor, enabling objects of the `Limiter` class to be used as if they
-   * were functions.
-   *
-   * @tparam T The data type of the scalar values and the return type.
-   * @param phi_upwind The scalar value at the upwind location.
-   * @param phi_downwind The scalar value at the downwind location.
-   * @param grad_phi_upwind Pointer to the gradient vector at the upwind location.
-   * @param grad_phi_downwind Pointer to the gradient vector at the downwind location.
+   * @tparam T The data type of the field values and the return type.
+   * @param phi_upwind The field value at the upwind location.
+   * @param phi_downwind The field value at the downwind location.
+   * @param grad_phi_upwind Pointer to the gradient at the upwind location.
+   * @param grad_phi_downwind Pointer to the gradient at the downwind location.
    * @param dCD A constant direction vector representing the direction of the cell face.
    * @param max_value The maximum allowable value.
    * @param min_value The minimum allowable value.
@@ -192,30 +137,6 @@ class Limiter
    * centroids.
    * @param fi_elem_is_upwind Boolean indicating if the face info element is upwind.
    * @return The result of the `limit` function applied to the provided parameters.
-   *
-   * This function performs the following steps:
-   * 1. Calls the `limit` method with the provided scalar values, gradient vectors, direction
-   * vector, maximum and minimum values, face information, and upwind status.
-   * 2. Returns the result of the `limit` method.
-   *
-   * This functor allows for more intuitive and flexible usage of the `Limiter` class, enabling
-   * instances of the class to be called with arguments directly.
-   *
-   * @example
-   * @code
-   * Limiter<Real> * myLimiter = ... // Assume this is properly initialized
-   * Real phi_upwind = 2.0;
-   * Real phi_downwind = 1.5;
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * VectorValue<Real> grad_downwind(0.4, 0.5, 0.6);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * Real max_value = 5.0;
-   * Real min_value = 1.0;
-   * FaceInfo * fi = ... // Assume this is properly initialized
-   * bool is_upwind = true;
-   * Real result = (*myLimiter)(phi_upwind, phi_downwind, &grad_upwind, &grad_downwind, dCD,
-   * max_value, min_value, fi, is_upwind);
-   * @endcode
    */
   T operator()(const T & phi_upwind,
                const T & phi_downwind,
@@ -239,34 +160,11 @@ class Limiter
   }
 
   /**
-   * @brief Computes the flux limiting ratio using gradients.
-   * This method works well for incompressible and compressible flow.
-   *
-   * This function calculates the flux limiting ratio based on the provided gradients
-   * at the upwind and downwind locations, along with a direction vector.
-   *
    * @tparam T The data type of the gradient values and the return type.
-   * @param grad_phi_upwind Pointer to the gradient vector at the upwind location.
-   * @param grad_phi_downwind Pointer to the gradient vector at the downwind location.
+   * @param grad_phi_upwind Pointer to the gradient at the upwind location.
+   * @param grad_phi_downwind Pointer to the gradient at the downwind location.
    * @param dCD A constant direction vector representing the direction of the cell face.
    * @return The computed flux limiting ratio.
-   *
-   * This function performs the following steps:
-   * 1. Computes the dot product of the upwind gradient vector with the direction vector `dCD`.
-   * 2. Computes the dot product of the downwind gradient vector with the direction vector `dCD`.
-   * 3. Calculates the ratio of the upwind gradient dot product to the downwind gradient dot
-   * product, adding a small epsilon value to the denominator to prevent division by zero.
-   *
-   * @note The small epsilon value `1e-10` is added to the denominator to avoid division by zero
-   *       and numerical instability.
-   *
-   * @example
-   * @code
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * VectorValue<Real> grad_downwind(0.4, 0.5, 0.6);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * Real ratio = rf_grad(&grad_upwind, &grad_downwind, dCD);
-   * @endcode
    */
   T rf_grad(const VectorValue<T> * grad_phi_upwind,
             const VectorValue<T> * grad_phi_downwind,
@@ -279,34 +177,15 @@ class Limiter
   };
 
   /**
-   * @brief Computes the flux limiting ratio using successive deltas.
-   *
-   * This function calculates the flux limiting ratio based on the upwind value,
-   * its gradient, maximum and minimum allowable values, and geometric information
-   * from the face and cell centroids.
-   *
-   * @tparam T The data type of the scalar values and the return type.
-   * @param phi_upwind The scalar value at the upwind location.
-   * @param grad_phi_upwind Pointer to the gradient vector at the upwind location.
+   * @tparam T The data type of the field values and the return type.
+   * @param phi_upwind The field value at the upwind location.
+   * @param grad_phi_upwind Pointer to the gradient at the upwind location.
    * @param max_value The maximum allowable value.
    * @param min_value The minimum allowable value.
    * @param fi FaceInfo object containing geometric details such as face centroid and cell
    * centroids.
    * @param fi_elem_is_upwind Boolean indicating if the face info element is upwind.
    * @return The computed flux limiting ratio.
-   *
-   * This function performs the following steps:
-   * 1. Retrieves the face centroid from the `FaceInfo` object.
-   * 2. Determines the cell centroid based on whether the current element is upwind.
-   * 3. Computes the delta value at the face by taking the dot product of the upwind gradient
-   *    vector with the difference between the face and cell centroids.
-   * 4. Computes the delta values for the maximum and minimum allowable values, adding a small
-   *    epsilon value to prevent division by zero.
-   * 5. Calculates the flux limiting ratio based on whether the delta value at the face is
-   *    non-negative or negative, using the appropriate delta (either max or min).
-   *
-   * @note The small epsilon value `1e-10` is added to the delta max and delta min values to
-   *       avoid division by zero and numerical instability.
    */
   T rf_minmax(const T & phi_upwind,
               const VectorValue<T> * grad_phi_upwind,
diff --git a/framework/include/limiters/MinModLimiter.h b/framework/include/limiters/MinModLimiter.h
index 5ff074710add..a70f3a6814de 100644
--- a/framework/include/limiters/MinModLimiter.h
+++ b/framework/include/limiters/MinModLimiter.h
@@ -17,11 +17,7 @@ namespace Moose
 namespace FV
 {
 /**
- * @brief Implements the Min-Mod limiter for flux limiting in numerical methods.
- *
- * The Min-Mod limiter is used to reduce numerical oscillations and
- * enforce monotonicity in computational fluid dynamics (CFD) and other numerical simulations.
- * The limiter function $\beta(r_f)$ is defined as:
+ * The Min-Mod limiter function $\beta(r_f)$ is defined as:
  *
  * \f[
  * \beta(r_f) = \text{max}(0, \text{min}(1, r_f))
@@ -36,8 +32,6 @@ class MinModLimiter : public Limiter<T>
 {
 public:
   /**
-   * @brief Computes the limited value using the Min-Mod limiter.
-   *
    * This method overrides the pure virtual `limit` method in the base `Limiter` class.
    * It calculates the flux limiting ratio based on the Min-Mod limiter formula.
    *
@@ -45,22 +39,6 @@ class MinModLimiter : public Limiter<T>
    * @param grad_phi_downwind Pointer to the gradient vector at the downwind location.
    * @param dCD A constant direction vector representing the direction of the cell face.
    * @return The computed flux limiting ratio.
-   *
-   * This method performs the following steps:
-   * 1. Asserts that the upwind gradient pointer is not null.
-   * 2. Computes the gradient ratio coefficient \( r_f \) using the `rf_grad` method.
-   * 3. Applies the Min-Mod limiter formula to \( r_f \) to obtain the limited value.
-   * 4. Returns the computed limited value.
-   *
-   * @example
-   * @code
-   * MinModLimiter<Real> minMod;
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * VectorValue<Real> grad_downwind(0.4, 0.5, 0.6);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * Real result = minMod.limit(0.0, 0.0, &grad_upwind, &grad_downwind, dCD, 0.0, 0.0, nullptr,
-   * true);
-   * @endcode
    */
   T limit(const T & phi_upwind,
           const T & phi_downwind,
@@ -89,9 +67,6 @@ class MinModLimiter : public Limiter<T>
 
   InterpMethod interpMethod() const override final { return InterpMethod::MinMod; }
 
-  /**
-   * @brief Default constructor for the Min-Mod limiter.
-   */
   MinModLimiter() = default;
 };
 }
diff --git a/framework/include/limiters/QUICKLimiter.h b/framework/include/limiters/QUICKLimiter.h
index b9faeaa940b2..38355ddda121 100644
--- a/framework/include/limiters/QUICKLimiter.h
+++ b/framework/include/limiters/QUICKLimiter.h
@@ -17,13 +17,8 @@ namespace Moose
 namespace FV
 {
 /**
- * @brief Implements the QUICK limiter for flux limiting in numerical methods.
- *
- * The QUICK (Quadratic Upstream Interpolation for Convective Kinematics) limiter is used to reduce
- * numerical oscillations and enforce monotonicity in computational fluid dynamics (CFD) and other
- * numerical simulations. This limiter ensures Total Variation Diminishing (TVD) compliance.
- *
- * The limiter function is derived from the following equations:
+ * The QUICK (Quadratic Upstream Interpolation for Convective Kinematics) limiter
+ * function is derived from the following equations:
  *
  * 1. Calculation of the gradient ratio coefficient \( r_f \):
  * \f[
@@ -45,8 +40,6 @@ class QUICKLimiter : public Limiter<T>
 {
 public:
   /**
-   * @brief Computes the limited value using the QUICK limiter.
-   *
    * This method overrides the pure virtual `limit` method in the base `Limiter` class.
    * It calculates the flux limiting ratio based on the QUICK limiter formula.
    *
@@ -56,23 +49,6 @@ class QUICKLimiter : public Limiter<T>
    * @param grad_phi_downwind Pointer to the gradient vector at the downwind location.
    * @param dCD A constant direction vector representing the direction of the cell face.
    * @return The computed flux limiting ratio.
-   *
-   * This method performs the following steps:
-   * 1. Asserts that the upwind gradient pointer is not null.
-   * 2. Computes the gradient ratio coefficient \( r_f \) using the `rf_grad` method or `rF` method.
-   * 3. Applies the QUICK limiter formula to \( r_f \) to obtain the limited value, ensuring TVD
-   * compliance.
-   * 4. Returns the computed limited value.
-   *
-   * @example
-   * @code
-   * QUICKLimiter<Real> quick;
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * VectorValue<Real> grad_downwind(0.4, 0.5, 0.6);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * Real result = quick.limit(0.0, 0.0, &grad_upwind, &grad_downwind, dCD, 0.0, 0.0, nullptr,
-   * true);
-   * @endcode
    */
   T limit(const T & phi_upwind,
           const T & phi_downwind,
@@ -111,9 +87,6 @@ class QUICKLimiter : public Limiter<T>
 
   InterpMethod interpMethod() const override final { return InterpMethod::QUICK; }
 
-  /**
-   * @brief Default constructor for the QUICK limiter.
-   */
   QUICKLimiter() = default;
 };
 }
diff --git a/framework/include/limiters/SOULimiter.h b/framework/include/limiters/SOULimiter.h
index cf182d2a6a34..020e18c6ae70 100644
--- a/framework/include/limiters/SOULimiter.h
+++ b/framework/include/limiters/SOULimiter.h
@@ -17,8 +17,6 @@ namespace Moose
 namespace FV
 {
 /**
- * @brief Implements the Second-Order Upwind (SOU) limiter for flux limiting in numerical methods.
- *
  * The SOU limiter is used for reproducing the second-order-upwind scheme. The limiter function
  * $\beta(delta_max)$ is defined as:
  *
@@ -37,8 +35,6 @@ class SOULimiter : public Limiter<T>
 {
 public:
   /**
-   * @brief Computes the limited value using the SOU limiter.
-   *
    * This method overrides the pure virtual `limit` method in the base `Limiter` class.
    * It calculates the flux limiting ratio based on the SOU limiter formula.
    *
@@ -50,27 +46,6 @@ class SOULimiter : public Limiter<T>
    * @param fi Pointer to the face information structure.
    * @param fi_elem_is_upwind Boolean flag indicating if the current element is upwind.
    * @return The computed flux limiting ratio.
-   *
-   * This method performs the following steps:
-   * 1. Asserts that the upwind gradient pointer is not null.
-   * 2. Handles initialization conflict by determining the face centroid and the appropriate cell
-   * centroid.
-   * 3. Computes the absolute delta value at the face.
-   * 4. Computes the delta between the two elements.
-   * 5. Returns the limited value based on the computed deltas.
-   *
-   * @example
-   * @code
-   * SOULimiter<Real> sou;
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * Real max_value = 1.0;
-   * Real min_value = 0.0;
-   * FaceInfo fi;
-   * bool fi_elem_is_upwind = true;
-   * Real result = sou.limit(0.0, 0.0, &grad_upwind, nullptr, dCD, max_value, min_value, &fi,
-   * fi_elem_is_upwind);
-   * @endcode
    */
   T limit(const T & phi_upwind,
           const T & phi_downwind,
@@ -116,9 +91,6 @@ class SOULimiter : public Limiter<T>
 
   InterpMethod interpMethod() const override final { return InterpMethod::SOU; }
 
-  /**
-   * @brief Default constructor for the SOU limiter.
-   */
   SOULimiter() = default;
 };
 }
diff --git a/framework/include/limiters/VanLeerLimiter.h b/framework/include/limiters/VanLeerLimiter.h
index ec07d948e4a2..8ed61b409fb0 100644
--- a/framework/include/limiters/VanLeerLimiter.h
+++ b/framework/include/limiters/VanLeerLimiter.h
@@ -17,11 +17,7 @@ namespace Moose
 namespace FV
 {
 /**
- * @brief Implements the Van Leer limiter for flux limiting in numerical methods.
- *
- * The Van Leer limiter is a slope limiter used to reduce numerical oscillations and
- * enforce monotonicity in computational fluid dynamics (CFD) and other numerical simulations.
- * The limiter function $\beta(r_f)$ is defined as:
+ * The Van Leer limiter limiter function $\beta(r_f)$ is defined as:
  *
  * \f[
  * \beta(r_f) = \frac{r_f + \text{abs}(r_f)}{1 + \text{abs}(r_f)}
@@ -36,8 +32,6 @@ class VanLeerLimiter : public Limiter<T>
 {
 public:
   /**
-   * @brief Computes the limited value using the Van Leer limiter.
-   *
    * This method overrides the pure virtual `limit` method in the base `Limiter` class.
    * It calculates the flux limiting ratio based on the Van Leer limiter formula.
    *
@@ -45,22 +39,6 @@ class VanLeerLimiter : public Limiter<T>
    * @param grad_phi_downwind Pointer to the gradient vector at the downwind location.
    * @param dCD A constant direction vector representing the direction of the cell face.
    * @return The computed flux limiting ratio.
-   *
-   * This method performs the following steps:
-   * 1. Asserts that the upwind and downwind gradient pointers are not null.
-   * 2. Computes the gradient ratio coefficient \( r_f \) using the `rf_grad` method.
-   * 3. Applies the Van Leer limiter formula to \( r_f \) to obtain the limited value.
-   * 4. Returns the computed limited value.
-   *
-   * @example
-   * @code
-   * VanLeerLimiter<Real> vanLeer;
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * VectorValue<Real> grad_downwind(0.4, 0.5, 0.6);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * Real result = vanLeer.limit(0.0, 0.0, &grad_upwind, &grad_downwind, dCD, 0.0, 0.0, nullptr,
-   * true);
-   * @endcode
    */
   T limit(const T & phi_upwind,
           const T & phi_downwind,
@@ -89,9 +67,6 @@ class VanLeerLimiter : public Limiter<T>
 
   InterpMethod interpMethod() const override final { return InterpMethod::VanLeer; }
 
-  /**
-   * @brief Default constructor for the Van Leer limiter.
-   */
   VanLeerLimiter() = default;
 };
 }
diff --git a/framework/include/limiters/VenkatakrishnanLimiter.h b/framework/include/limiters/VenkatakrishnanLimiter.h
index ab7078d573cb..ae9da92c3100 100644
--- a/framework/include/limiters/VenkatakrishnanLimiter.h
+++ b/framework/include/limiters/VenkatakrishnanLimiter.h
@@ -17,14 +17,7 @@ namespace Moose
 namespace FV
 {
 /**
- * @brief Implements the Venkatakrishnan limiter for flux limiting.
- *
- * The Venkatakrishnan limiter is used to reduce numerical oscillations and enforce monotonicity
- * in computational fluid dynamics (CFD) and other numerical simulations. This limiter adjusts
- * the flux limiting ratio based on face centroids and cell centroids, handling different gradient
- * conditions.
- *
- * The limiter function is derived from the following equations:
+ * The Venkatakrishnan limiter is derived from the following equations:
  *
  * 1. Calculation of the face delta:
  * \f[
@@ -56,8 +49,6 @@ class VenkatakrishnanLimiter : public Limiter<T>
 {
 public:
   /**
-   * @brief Computes the limited value using the Venkatakrishnan limiter.
-   *
    * This method overrides the pure virtual `limit` method in the base `Limiter` class.
    * It calculates the flux limiting ratio based on the Venkatakrishnan limiter formula.
    *
@@ -68,27 +59,6 @@ class VenkatakrishnanLimiter : public Limiter<T>
    * @param fi Pointer to the face information structure.
    * @param fi_elem_is_upwind Boolean flag indicating if the current element is upwind.
    * @return The computed flux limiting ratio.
-   *
-   * This method performs the following steps:
-   * 1. Determines the face centroid and the appropriate cell centroid.
-   * 2. Computes the delta value at the face.
-   * 3. Computes deltas for the maximum and minimum values relative to the upwind value.
-   * 4. Computes the ratio \( r_f \) based on the sign of the delta face value.
-   * 5. Applies the Venkatakrishnan limiter formula to \( r_f \) to obtain the limited value.
-   * 6. Returns the computed limited value.
-   *
-   * @example
-   * @code
-   * VenkatakrishnanLimiter<Real> venkatakrishnan;
-   * VectorValue<Real> grad_upwind(0.1, 0.2, 0.3);
-   * RealVectorValue dCD(1.0, 0.0, 0.0);
-   * Real max_value = 1.0;
-   * Real min_value = 0.0;
-   * FaceInfo fi;
-   * bool fi_elem_is_upwind = true;
-   * Real result = venkatakrishnan.limit(0.0, 0.0, &grad_upwind, nullptr, dCD, max_value, min_value,
-   * &fi, fi_elem_is_upwind);
-   * @endcode
    */
   T limit(const T & phi_upwind,
           const T & /* phi_downwind */,
@@ -117,9 +87,6 @@ class VenkatakrishnanLimiter : public Limiter<T>
 
   InterpMethod interpMethod() const override final { return InterpMethod::SOU; }
 
-  /**
-   * @brief Default constructor for the Venkatakrishnan limiter.
-   */
   VenkatakrishnanLimiter() = default;
 };
 }
diff --git a/framework/include/utils/MathFVUtils.h b/framework/include/utils/MathFVUtils.h
index 71dbf709ef13..3e07407219d9 100644
--- a/framework/include/utils/MathFVUtils.h
+++ b/framework/include/utils/MathFVUtils.h
@@ -558,8 +558,6 @@ interpolate(const Limiter & limiter,
 }
 
 /**
- * @brief Computes the full limited interpolation of a variable using a specified limiter.
- *
  * This function performs a full limited interpolation of a variable, taking into account
  * the values and gradients at both upwind and downwind locations, as well as geometric
  * information and limits. It applies the specified limiter to ensure the interpolation
@@ -567,26 +565,15 @@ interpolate(const Limiter & limiter,
  *
  * @tparam T The data type of the scalar values and the return type.
  * @param limiter The limiter object used to compute the flux limiting ratio.
- * @param phi_upwind The scalar value at the upwind location.
- * @param phi_downwind The scalar value at the downwind location.
- * @param grad_phi_upwind Pointer to the gradient vector at the upwind location.
- * @param grad_phi_face Pointer to the gradient vector at the face location.
+ * @param phi_upwind The field value at the upwind location.
+ * @param phi_downwind The field value at the downwind location.
+ * @param grad_phi_upwind Pointer to the gradient at the upwind location.
+ * @param grad_phi_face Pointer to the gradient at the face location.
  * @param fi FaceInfo object containing geometric details such as face centroid and cell centroids.
  * @param fi_elem_is_upwind Boolean indicating if the face info element is upwind.
  * @param max_value The maximum allowable value.
  * @param min_value The minimum allowable value.
  * @return The computed limited interpolation value.
- *
- * This function performs the following steps:
- * 1. Computes the direction vector \( dCD \) based on whether the current element is upwind.
- * 2. Calls the `limiter` functor with the provided scalar values, gradient vectors, direction
- * vector, and geometric information to compute the flux limiting ratio \( \beta \).
- * 3. Determines the face centroid and the appropriate cell centroid based on whether the current
- * element is upwind.
- * 4. Computes the delta value at the face by taking the dot product of the upwind gradient vector
- * with the difference between the face and cell centroids.
- * 5. Returns the interpolated value by adding the product of the limiter \( \beta \) and the delta
- * value to the upwind scalar value.
  */
 template <typename T>
 T
@@ -630,9 +617,6 @@ fullLimitedInterpolation(const Limiter<T> & limiter,
 }
 
 /**
- * @brief Computes the minimum and maximum scalar values in a two-cell stencil around a given face
- * in a computational grid.
- *
  * This function calculates the minimum and maximum values within a two-cell stencil. The stencil
  * includes the immediate neighboring elements of the face's associated element and the neighboring
  * elements of those neighbors. It evaluates the values using a provided functor and accounts for
@@ -653,21 +637,6 @@ fullLimitedInterpolation(const Limiter<T> & limiter,
  * @return std::pair<T, T> A pair containing the minimum and maximum values computed across the
  * two-cell stencil. The first element is the maximum value, and the second element is the minimum
  * value.
- *
- * This function performs the following steps:
- * 1. Initializes max_value to 0 and min_value to a large value.
- * 2. Iterates over the direct neighbors of the element associated with the face.
- *    - If a neighbor is valid (not null), it evaluates the functor at that neighbor and updates
- * max_value and min_value.
- * 3. Iterates over the neighbors of the neighbors.
- *    - Similar to the first loop, it evaluates the functor at valid neighbors and updates max_value
- * and min_value.
- * 4. Returns a pair containing the computed max_value and min_value.
- *
- * Usage:
- * This function is typically used in the finite volume methods for min-max computations over
- * stencils (neighborhoods). It helps compute the limiting for limited second order upwind at the
- * faces.
  */
 template <typename T,
           FunctorEvaluationKind FEK = FunctorEvaluationKind::Value,
@@ -713,9 +682,6 @@ computeMinMaxValue(const FunctorBase<T> & functor, const FaceArg & face, const S
 }
 
 /**
- * @brief Computes the minimum and maximum scalar values of a specific component in a two-cell
- * stencil around a given face in a computational grid.
- *
  * This function calculates the minimum and maximum values of a specified component within a
  * two-cell stencil. The stencil includes the immediate neighboring elements of the face's
  * associated element and the neighboring elements of those neighbors. It evaluates the values using
@@ -735,16 +701,6 @@ computeMinMaxValue(const FunctorBase<T> & functor, const FaceArg & face, const S
  * component computed across the two-cell stencil. The first element is the maximum value, and the
  * second element is the minimum value.
  *
- * This function performs the following steps:
- * 1. Initializes max_value to 0 and min_value to a large value.
- * 2. Iterates over the direct neighbors of the element associated with the face.
- *    - If a neighbor is valid (not null), it evaluates the functor at that neighbor for the
- * specified component and updates max_value and min_value.
- * 3. Iterates over the neighbors of the neighbors.
- *    - Similar to the first loop, it evaluates the functor at valid neighbors for the specified
- * component and updates max_value and min_value.
- * 4. Returns a pair containing the computed max_value and min_value.
- *
  * Usage:
  * This function is typically used in the finite volume methods for min-max computations over
  * stencils (neighborhoods). It helps compute the limiting for limited second order upwind at the
@@ -795,8 +751,6 @@ computeMinMaxValue(const FunctorBase<VectorValue<T>> & functor,
 }
 
 /**
- * @brief Interpolates with a limiter and a face argument.
- *
  * This function interpolates values using a specified limiter and face argument. It evaluates the
  * values at upwind and downwind locations and computes interpolation coefficients and advected
  * values.
@@ -820,15 +774,6 @@ computeMinMaxValue(const FunctorBase<VectorValue<T>> & functor,
  *                         - The second pair corresponds to the face information functor element
  * value and neighbor value.
  *
- * This function performs the following steps:
- * 1. Asserts that the face information is non-null.
- * 2. Constructs a limiter based on the face limiter type.
- * 3. Determines the upwind and downwind arguments based on the face element.
- * 4. Evaluates the functor at the upwind and downwind locations.
- * 5. Computes the interpolation coefficients using the specified limiter.
- * 6. If necessary, computes the gradient and min-max values for certain limiter types.
- * 7. Returns the interpolation coefficients and advected values.
- *
  * Usage:
  * This function is used for interpolating values at faces in a finite volume method, ensuring that
  * the interpolation adheres to the constraints imposed by the limiter.
@@ -848,7 +793,6 @@ interpCoeffsAndAdvected(const FunctorBase<T> & functor, const FaceArg & face, co
   typedef typename FunctorBase<T>::GradientType GradientType;
   static const GradientType zero(0);
 
-  // Assert that the face information is non-null
   mooseAssert(face.fi, "this must be non-null");
 
   // Construct the limiter based on the face limiter type
@@ -868,7 +812,6 @@ interpCoeffsAndAdvected(const FunctorBase<T> & functor, const FaceArg & face, co
   // Compute interpolation coefficients for Upwind or CentralDifference limiters
   if (face.limiter_type == LimiterType::Upwind ||
       face.limiter_type == LimiterType::CentralDifference)
-  {
     interp_coeffs = interpCoeffs(*limiter,
                                  phi_upwind,
                                  phi_downwind,
@@ -878,7 +821,6 @@ interpCoeffsAndAdvected(const FunctorBase<T> & functor, const FaceArg & face, co
                                  std::numeric_limits<Real>::min(),
                                  *face.fi,
                                  face.elem_is_upwind);
-  }
   else
   {
     // Determine the time argument for the limiter
@@ -893,9 +835,7 @@ interpCoeffsAndAdvected(const FunctorBase<T> & functor, const FaceArg & face, co
 
     // Compute min-max values for min-max limiters
     if (face.limiter_type == LimiterType::Venkatakrishnan || face.limiter_type == LimiterType::SOU)
-    {
       std::tie(max_value, min_value) = computeMinMaxValue(functor, face, *time_arg);
-    }
 
     // Evaluate the gradient of the functor at the upwind and downwind locations
     const auto grad_phi_upwind = functor.template genericEvaluate<GFEK>(upwind_arg, *time_arg);
@@ -924,8 +864,6 @@ interpCoeffsAndAdvected(const FunctorBase<T> & functor, const FaceArg & face, co
 }
 
 /**
- * @brief Interpolates values using a specified functor and face argument.
- *
  * This function interpolates values at faces in a computational grid using a specified functor,
  * face argument, and evaluation kind. It handles different limiter types and performs
  * interpolation accordingly.
@@ -944,14 +882,6 @@ interpCoeffsAndAdvected(const FunctorBase<T> & functor, const FaceArg & face, co
  *
  * @return T The interpolated value at the face.
  *
- * This function performs the following steps:
- * 1. Checks that only supported FunctorEvaluationKinds are used.
- * 2. Handles central differencing separately as it supports skew correction.
- * 3. For Upwind or CentralDifference limiters, computes interpolation coefficients and advected
- * values.
- * 4. For other limiter types, computes the gradient and min-max values if necessary, and performs
- * full limited interpolation.
- *
  * Usage:
  * This function is used for interpolating values at faces in a finite volume method, ensuring that
  * the interpolation adheres to the constraints imposed by the limiter.
@@ -1024,8 +954,6 @@ interpolate(const FunctorBase<T> & functor, const FaceArg & face, const StateArg
 }
 
 /**
- * @brief Interpolates vector values using a specified functor and face argument.
- *
  * This function interpolates vector values at faces in a computational grid using a specified
  * functor, face argument, and limiter type. It handles different limiter types and performs
  * interpolation accordingly.
@@ -1041,15 +969,6 @@ interpolate(const FunctorBase<T> & functor, const FaceArg & face, const StateArg
  *
  * @return VectorValue<T> The interpolated vector value at the face.
  *
- * This function performs the following steps:
- * 1. Asserts that the face information is non-null.
- * 2. Constructs a limiter based on the face limiter type.
- * 3. Determines the upwind and downwind arguments based on the face element.
- * 4. Evaluates the functor at the upwind and downwind locations.
- * 5. Initializes the return vector value.
- * 6. Computes the interpolation coefficients and advected values for each component.
- * 7. If necessary, computes the gradient and min-max values for certain limiter types.
- *
  * Usage:
  * This function is used for interpolating vector values at faces in a finite volume method,
  * ensuring that the interpolation adheres to the constraints imposed by the limiter.
@@ -1063,7 +982,6 @@ interpolate(const FunctorBase<VectorValue<T>> & functor,
   // Define a zero gradient vector for initialization
   static const VectorValue<T> grad_zero(0);
 
-  // Assert that the face information is non-null
   mooseAssert(face.fi, "this must be non-null");
 
   // Construct the limiter based on the face limiter type
@@ -1145,8 +1063,6 @@ interpolate(const FunctorBase<VectorValue<T>> & functor,
 }
 
 /**
- * @brief Interpolates container values using a specified functor and face argument.
- *
  * This function interpolates container values at faces in a computational grid using a specified
  * functor, face argument, and limiter type. It handles different limiter types and performs
  * interpolation accordingly.
@@ -1162,15 +1078,6 @@ interpolate(const FunctorBase<VectorValue<T>> & functor,
  *
  * @return T The interpolated container value at the face.
  *
- * This function performs the following steps:
- * 1. Asserts that the face information is non-null.
- * 2. Constructs a limiter based on the face limiter type.
- * 3. Determines the upwind and downwind arguments based on the face element.
- * 4. Evaluates the functor at the upwind and downwind locations.
- * 5. Initializes the return container value.
- * 6. Computes the interpolation coefficients and advected values for each component.
- * 7. If necessary, computes the gradient and min-max values for certain limiter types.
- *
  * Usage:
  * This function is used for interpolating container values at faces in a finite volume method,
  * ensuring that the interpolation adheres to the constraints imposed by the limiter.