Merge pull request #32153 from grmnptr/frozen-fields-32151

Make sure we can disable different parts of the segregated solve after restart.

Author: grmnptr

framework/include/base/Moose.h

@@ -14,6 +14,7 @@
 #include "libmesh/libmesh_common.h"
 #include "XTermConstants.h"
 
+#include <limits>
 #include <memory>
 #include <set>
 #include <string>
@@ -161,6 +162,9 @@ static_assert(LIBMESH_DIM == 3,
  */
 static constexpr std::size_t dim = LIBMESH_DIM;
 
+/// Value for invalid size_t indices
+inline constexpr std::size_t invalid_size_t = std::numeric_limits<std::size_t>::max();
+
 /**
  * Used by the signal handler to determine if we should write a checkpoint file out at any point
  * during operation.

modules/navier_stokes/doc/config.yml

@@ -4,6 +4,10 @@ Content:
     - modules/fluid_properties/doc/content
     - modules/heat_transfer/doc/content
     - modules/ray_tracing/doc/content
+    - utility:
+        root_dir: ${MOOSE_DIR}/modules/doc/content
+        content:
+            - application_usage/restart_recover.md
 
 Renderer:
     type: MooseDocs.base.MaterializeRenderer

modules/navier_stokes/doc/content/source/executioners/PIMPLE.md

@@ -40,6 +40,37 @@ block is different:
 
 !listing modules/navier_stokes/test/tests/finite_volume/ins/channel-flow/linear-segregated/2d/2d-boussinesq-transient.i block=Executioner
 
+### Restarting and keeping certain solution fields unchanged
+
+When recovering from a checkpoint, it can be useful to hold the thermal-hydraulics fields fixed
+and only advance other systems. The `PIMPLE` executioner exposes flags that selectively disable parts
+of the segregated solve:
+
+- [!param](/Executioner/PIMPLE/should_solve_momentum)
+- [!param](/Executioner/PIMPLE/should_solve_pressure)
+- [!param](/Executioner/PIMPLE/should_solve_energy)
+- [!param](/Executioner/PIMPLE/should_solve_solid_energy)
+- [!param](/Executioner/PIMPLE/should_solve_turbulence)
+- [!param](/Executioner/PIMPLE/should_solve_active_scalars)
+- [!param](/Executioner/PIMPLE/should_solve_passive_scalars)
+
+For example, to load a converged flow/temperature field from a steady-state run and only march
+passive scalars, enable [restart and recovery](restart_recover.md optional=True), keep the scalar solves enabled, and disable the momentum,
+pressure, and energy solves:
+
+```
+[Problem]
+  restart_file_base=converged_run_cp/LATEST
+[]
+[Executioner]
+  type = PIMPLE
+  ...
+  should_solve_momentum = false
+  should_solve_pressure = false
+  should_solve_energy = false
+[]
+```
+
 !syntax parameters /Executioner/PIMPLE
 
 !syntax inputs /Executioner/PIMPLE

modules/navier_stokes/doc/content/source/executioners/SIMPLE.md

@@ -157,6 +157,37 @@ Several systems may be used, for each passive scalar.
 
 For the conjuagate heat transfer capabilities visit the [corresponding design page](linear_fv_cht.md)
 
+### Restarting and keeping certain solution fields unchanged
+
+When recovering from a checkpoint, it can be useful to hold the thermal-hydraulics fields fixed
+and only advance other systems. The `PIMPLE` executioner exposes flags that selectively disable parts
+of the segregated solve:
+
+- [!param](/Executioner/SIMPLE/should_solve_momentum)
+- [!param](/Executioner/SIMPLE/should_solve_pressure)
+- [!param](/Executioner/SIMPLE/should_solve_energy)
+- [!param](/Executioner/SIMPLE/should_solve_solid_energy)
+- [!param](/Executioner/SIMPLE/should_solve_turbulence)
+- [!param](/Executioner/SIMPLE/should_solve_active_scalars)
+- [!param](/Executioner/SIMPLE/should_solve_passive_scalars)
+
+For example, to load a converged flow/temperature field from a steady-state run and only march
+passive scalars, enable [restart and recovery](restart_recover.md optional=True), keep the scalar solves enabled, and disable the momentum,
+pressure, and energy solves:
+
+```
+[Problem]
+  restart_file_base=converged_run_cp/LATEST
+[]
+[Executioner]
+  type = SIMPLE
+  ...
+  should_solve_momentum = false
+  should_solve_pressure = false
+  should_solve_energy = false
+[]
+```
+
 !syntax parameters /Executioner/SIMPLE
 
 !syntax inputs /Executioner/SIMPLE

modules/navier_stokes/include/executioners/LinearAssemblySegregatedSolve.h

@@ -72,6 +72,35 @@ class LinearAssemblySegregatedSolve : public SIMPLESolveBase
                       const Real field_relaxation = 1.0,
                       const Real min_value_limiter = std::numeric_limits<Real>::min());
 
+  /// Aggregated storage for residuals, tolerances, and indices used in convergence checks
+  struct ResidualStorage
+  {
+    /// (linear iterations, normalized residual) entries in the order used by NS::FV::converged()
+    std::vector<std::pair<unsigned int, Real>> ns_residuals;
+    /// Absolute tolerances matching ns_residuals
+    std::vector<Real> ns_abs_tols;
+    /// Indices of momentum equations in ns_residuals
+    std::vector<std::size_t> momentum_indices;
+    /// Index of the pressure equation in ns_residuals
+    std::size_t pressure_index = Moose::invalid_size_t;
+    /// Index of the energy equation in ns_residuals
+    std::size_t energy_index = Moose::invalid_size_t;
+    /// Index of the solid energy equation in ns_residuals
+    std::size_t solid_energy_index = Moose::invalid_size_t;
+    /// Indices of active scalar equations in ns_residuals
+    std::vector<std::size_t> active_scalar_indices;
+    /// Indices of turbulence surrogate equations in ns_residuals
+    std::vector<std::size_t> turbulence_indices;
+    /// This will be an initial indicator if we have something to solve.
+    /// If we dont have anything we just set this to true.
+    bool converged = false;
+  };
+
+  /**
+   * Build residual/tolerance vectors and associated indices for all enabled systems.
+   */
+  ResidualStorage setupResidualStorage() const;
+
   /// Solve an equation which contains the solid energy conservation.
   std::pair<unsigned int, Real> solveSolidEnergy();
 
@@ -114,6 +143,15 @@ class LinearAssemblySegregatedSolve : public SIMPLESolveBase
   /// Shortcut to every linear system that we solve for here
   std::vector<LinearSystem *> _systems_to_solve;
 
+  /// Flags controlling which systems are actively solved (can be used with restart to freeze flow)
+  const bool _should_solve_momentum;
+  const bool _should_solve_pressure;
+  const bool _should_solve_energy;
+  const bool _should_solve_solid_energy;
+  const bool _should_solve_turbulence;
+  const bool _should_solve_passive_scalars;
+  const bool _should_solve_active_scalars;
+
   // ************************ Active Scalar Variables ************************ //
 
   /// The names of the active scalar systems