https://mooseframework.inl.gov
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
SIMPLESolve Class Reference

Implementation of Semi-Implicit Method for Pressure-Linked Equations (SIMPLE) with MOOSE-based applications. More...

#include <SIMPLESolve.h>

Inheritance diagram for SIMPLESolve:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 SIMPLESolve (Executioner &ex)
 
virtual void checkIntegrity () override
 Check if the user defined time kernels, if yes error out. More...
 
virtual void linkRhieChowUserObject () override
 Fetch the Rhie Chow user object that is reponsible for determining face velocities and mass flux. More...
 
virtual void initialSetup () override
 
virtual bool solve () override
 Performs the momentum pressure coupling. More...
 
const std::vector< LinearSystem * > systemsToSolve () const
 Return pointers to the systems which are solved for within this object. More...
 
virtual void setInnerSolve (SolveObject &) override
 
void setupPressurePin ()
 Setup pressure pin if there is need for one. More...
 
virtual bool enabled () const
 
std::shared_ptr< MooseObject > getSharedPtr ()
 
std::shared_ptr< const MooseObject > getSharedPtr () const
 
bool isKokkosObject () const
 
MooseApp & getMooseApp () const
 
const std::string & type () const
 
const std::string & name () const
 
std::string typeAndName () const
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
const T & getParam (const std::string &name) const
 
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 
const T * queryParam (const std::string &name) const
 
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 
T getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 
bool haveParameter (const std::string &name) const
 
bool isParamValid (const std::string &name) const
 
bool isParamSetByUser (const std::string &name) const
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 
void paramError (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramWarning (const std::string &param, Args... args) const
 
void paramInfo (const std::string &param, Args... args) const
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 
void mooseError (Args &&... args) const
 
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
void mooseErrorNonPrefixed (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarning (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseWarningNonPrefixed (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecated (Args &&... args) const
 
void mooseDeprecatedNoTrace (Args &&... args) const
 
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 
std::string getDataFileName (const std::string &param) const
 
std::string getDataFileNameByName (const std::string &relative_path) const
 
std::string getDataFilePath (const std::string &relative_path) const
 
PerfGraph & perfGraph ()
 
bool isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
 
bool hasPostprocessor (const std::string &param_name, const unsigned int index=0) const
 
bool hasPostprocessorByName (const PostprocessorName &name) const
 
std::size_t coupledPostprocessors (const std::string &param_name) const
 
const PostprocessorName & getPostprocessorName (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValue & getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValue & getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValue & getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValue & getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValue & getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const
 
const PostprocessorValue & getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const
 
virtual const PostprocessorValue & getPostprocessorValueByName (const PostprocessorName &name) const
 
virtual const PostprocessorValue & getPostprocessorValueByName (const PostprocessorName &name) const
 
const PostprocessorValue & getPostprocessorValueOldByName (const PostprocessorName &name) const
 
const PostprocessorValue & getPostprocessorValueOldByName (const PostprocessorName &name) const
 
const PostprocessorValue & getPostprocessorValueOlderByName (const PostprocessorName &name) const
 
const PostprocessorValue & getPostprocessorValueOlderByName (const PostprocessorName &name) const
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 
UserObjectName getUserObjectName (const std::string &param_name) const
 
const T & getUserObject (const std::string &param_name, bool is_dependency=true) const
 
const T & getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const
 
const UserObjectBase & getUserObjectBase (const std::string &param_name, bool is_dependency=true) const
 
const UserObjectBase & getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObject (const std::string &param_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 
bool hasUserObjectByName (const UserObjectName &object_name) const
 

Static Public Member Functions

static InputParameters validParams ()
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 

Public Attributes

 usingCombinedWarningSolutionWarnings
 
const ConsoleStream _console
 

Static Public Attributes

static const std::string type_param
 
static const std::string name_param
 
static const std::string unique_name_param
 
static const std::string app_param
 
static const std::string moose_base_param
 
static const std::string kokkos_object_param
 

Protected Member Functions

virtual void checkTimeKernels (LinearSystem &system)
 Check if the system contains time kernels. More...
 
virtual std::vector< std::pair< unsigned int, Real > > solveMomentumPredictor () override
 Solve a momentum predictor step with a fixed pressure field. More...
 
virtual std::pair< unsigned int, Real > solvePressureCorrector () override
 Solve a pressure corrector step. More...
 
virtual std::pair< unsigned int, Real > correctVelocity (const bool subtract_updated_pressure, const bool recompute_face_mass_flux, const SolverParams &solver_params)
 Computes new velocity field based on computed pressure gradients. More...
 
std::pair< unsigned int, Real > solveAdvectedSystem (const unsigned int system_num, LinearSystem &system, const Real relaxation_factor, libMesh::SolverConfiguration &solver_config, const Real abs_tol, const Real field_relaxation=1.0, const Real min_value_limiter=std::numeric_limits< Real >::min())
 Solve an equation which contains an advection term that depends on the solution of the segregated Navier-Stokes equations. More...
 
ResidualStorage setupResidualStorage () const
 Build residual/tolerance vectors and associated indices for all enabled systems. More...
 
std::pair< unsigned int, Real > solveSolidEnergy ()
 Solve an equation which contains the solid energy conservation. More...
 
void checkDependentParameterError (const std::string &main_parameter, const std::vector< std::string > &dependent_parameters, const bool should_be_defined)
 
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 
virtual void addPostprocessorDependencyHelper (const PostprocessorName &) const
 
virtual void addUserObjectDependencyHelper (const UserObjectBase &) const
 

Protected Attributes

std::vector< unsigned int > _momentum_system_numbers
 The number(s) of the system(s) corresponding to the momentum equation(s) More...
 
std::vector< LinearSystem * > _momentum_systems
 Pointer(s) to the system(s) corresponding to the momentum equation(s) More...
 
const unsigned int _pressure_sys_number
 The number of the system corresponding to the pressure equation. More...
 
LinearSystem & _pressure_system
 Reference to the linear system corresponding to the pressure equation. More...
 
const unsigned int _energy_sys_number
 The number of the system corresponding to the energy equation. More...
 
LinearSystem * _energy_system
 Pointer to the linear system corresponding to the fluid energy equation. More...
 
const unsigned int _solid_energy_sys_number
 The number of the system corresponding to the solid energy equation. More...
 
LinearSystem * _solid_energy_system
 Pointer to the linear system corresponding to the solid energy equation. More...
 
std::vector< LinearSystem * > _passive_scalar_systems
 Pointer(s) to the system(s) corresponding to the passive scalar equation(s) More...
 
std::vector< LinearSystem * > _pm_radiation_systems
 Pointer(s) to the system(s) corresponding to the participting media radiation equation(s) More...
 
std::vector< LinearSystem * > _active_scalar_systems
 Pointer(s) to the system(s) corresponding to the active scalar equation(s) More...
 
std::vector< LinearSystem * > _turbulence_systems
 Pointer(s) to the system(s) corresponding to the turbulence equation(s) More...
 
RhieChowMassFlux * _rc_uo
 Pointer to the segregated RhieChow interpolation object. More...
 
std::vector< LinearSystem * > _systems_to_solve
 Shortcut to every linear system that we solve for here. More...
 
const bool _should_solve_momentum
 Flags controlling which systems are actively solved (can be used with restart to freeze flow) More...
 
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
 
const bool _should_solve_pm_radiation
 
const std::vector< SolverSystemName > & _active_scalar_system_names
 The names of the active scalar systems. More...
 
const bool _has_active_scalar_systems
 Boolean for easy check if a active scalar systems shall be solved or not. More...
 
std::vector< unsigned int > _active_scalar_system_numbers
 
const std::vector< Real > _active_scalar_equation_relaxation
 The user-defined relaxation parameter(s) for the active scalar equation(s) More...
 
Moose::PetscSupport::PetscOptions _active_scalar_petsc_options
 Options which hold the petsc settings for the active scalar equation(s) More...
 
SIMPLESolverConfiguration _active_scalar_linear_control
 Options for the linear solver of the active scalar equation(s) More...
 
const Real _active_scalar_l_abs_tol
 Absolute linear tolerance for the active scalar equation(s). More...
 
const std::vector< Real > _active_scalar_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in active scalars. More...
 
NS::FV::CHTHandler _cht
 ********************** Conjugate heat transfer variables ************** // More...
 
const std::vector< SolverSystemName > & _momentum_system_names
 The names of the momentum systems. More...
 
SIMPLESolverConfiguration _momentum_linear_control
 Options for the linear solver of the momentum equation. More...
 
const Real _momentum_l_abs_tol
 Absolute linear tolerance for the momentum equation(s). More...
 
Moose::PetscSupport::PetscOptions _momentum_petsc_options
 Options which hold the petsc settings for the momentum equation. More...
 
const Real _momentum_equation_relaxation
 The user-defined relaxation parameter for the momentum equation. More...
 
const SolverSystemName & _pressure_system_name
 The name of the pressure system. More...
 
SIMPLESolverConfiguration _pressure_linear_control
 Options for the linear solver of the pressure equation. More...
 
const Real _pressure_l_abs_tol
 Absolute linear tolerance for the pressure equation. More...
 
Moose::PetscSupport::PetscOptions _pressure_petsc_options
 Options which hold the petsc settings for the pressure equation. More...
 
const Real _pressure_variable_relaxation
 The user-defined relaxation parameter for the pressure variable. More...
 
const bool _pin_pressure
 If the pressure needs to be pinned. More...
 
const Real _pressure_pin_value
 The value we want to enforce for pressure. More...
 
dof_id_type _pressure_pin_dof
 The dof ID where the pressure needs to be pinned. More...
 
const bool _has_energy_system
 Boolean for easy check if a fluid energy system shall be solved or not. More...
 
const Real _energy_equation_relaxation
 The user-defined relaxation parameter for the energy equation. More...
 
Moose::PetscSupport::PetscOptions _energy_petsc_options
 Options which hold the petsc settings for the fluid energy equation. More...
 
SIMPLESolverConfiguration _energy_linear_control
 Options for the linear solver of the energy equation. More...
 
const Real _energy_l_abs_tol
 Absolute linear tolerance for the energy equations. More...
 
const bool _has_solid_energy_system
 Boolean for easy check if a solid energy system shall be solved or not. More...
 
Moose::PetscSupport::PetscOptions _solid_energy_petsc_options
 Options which hold the petsc settings for the fluid energy equation. More...
 
SIMPLESolverConfiguration _solid_energy_linear_control
 Options for the linear solver of the energy equation. More...
 
const Real _solid_energy_l_abs_tol
 Absolute linear tolerance for the energy equations. More...
 
const std::vector< SolverSystemName > & _passive_scalar_system_names
 The names of the passive scalar systems. More...
 
const bool _has_passive_scalar_systems
 Boolean for easy check if a passive scalar systems shall be solved or not. More...
 
std::vector< unsigned int > _passive_scalar_system_numbers
 
const std::vector< Real > _passive_scalar_equation_relaxation
 The user-defined relaxation parameter(s) for the passive scalar equation(s) More...
 
Moose::PetscSupport::PetscOptions _passive_scalar_petsc_options
 Options which hold the petsc settings for the passive scalar equation(s) More...
 
SIMPLESolverConfiguration _passive_scalar_linear_control
 Options for the linear solver of the passive scalar equation(s) More...
 
const Real _passive_scalar_l_abs_tol
 Absolute linear tolerance for the passive scalar equation(s). More...
 
const std::vector< SolverSystemName > & _pm_radiation_system_names
 The names of the participating media radiation systems. More...
 
const bool _has_pm_radiation_systems
 Boolean for easy check if participating media radiation systems shall be solved or not. More...
 
std::vector< unsigned int > _pm_radiation_system_numbers
 
const std::vector< Real > _pm_radiation_equation_relaxation
 The user-defined relaxation parameter(s) for the participating media radiation equation(s) More...
 
Moose::PetscSupport::PetscOptions _pm_radiation_petsc_options
 Options which hold the petsc settings for the participating media radiation equation(s) More...
 
SIMPLESolverConfiguration _pm_radiation_linear_control
 Options for the linear solver of the participating media radiation equation(s) More...
 
const Real _pm_radiation_l_abs_tol
 Absolute linear tolerance for the participating media radiation equation(s). More...
 
const std::vector< SolverSystemName > & _turbulence_system_names
 The names of the turbulence systems. More...
 
const bool _has_turbulence_systems
 Boolean for easy check if a turbulence scalar systems shall be solved or not. More...
 
std::vector< unsigned int > _turbulence_system_numbers
 
const std::vector< Real > _turbulence_equation_relaxation
 The user-defined relaxation parameter(s) for the turbulence equation(s) More...
 
std::vector< Real > _turbulence_field_relaxation
 The user-defined relaxation parameter(s) for the turbulence field(s) More...
 
std::vector< Real > _turbulence_field_min_limit
 The user-defined lower limit for turbulent quantities e.g. k, eps/omega, etc.. More...
 
Moose::PetscSupport::PetscOptions _turbulence_petsc_options
 Options which hold the petsc settings for the turbulence equation(s) More...
 
SIMPLESolverConfiguration _turbulence_linear_control
 Options for the linear solver of the turbulence equation(s) More...
 
const Real _turbulence_l_abs_tol
 Absolute linear tolerance for the turbulence equation(s). More...
 
const Real _momentum_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in momentum. More...
 
const Real _pressure_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in pressure. More...
 
const Real _energy_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in energy. More...
 
const Real _solid_energy_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in solid energy. More...
 
const std::vector< Real > _passive_scalar_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in passive scalars. More...
 
const std::vector< Real > _pm_radiation_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in participating media radiation. More...
 
const std::vector< Real > _turbulence_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence turbulence variables. More...
 
const unsigned int _num_iterations
 The maximum number of momentum-pressure iterations. More...
 
const bool _continue_on_max_its
 If solve should continue if maximum number of iterations is hit. More...
 
const bool _print_fields
 Debug parameter which allows printing the coupling and solution vectors/matrices. More...
 
Executioner & _executioner
 
FEProblemBase & _problem
 
DisplacedProblem * _displaced_problem
 
MooseMesh & _mesh
 
MooseMesh * _displaced_mesh
 
SystemBase & _solver_sys
 
AuxiliarySystem & _aux
 
SolveObject * _inner_solve
 
const bool & _enabled
 
MooseApp & _app
 
Factory & _factory
 
ActionFactory & _action_factory
 
const std::string & _type
 
const std::string & _name
 
const InputParameters & _pars
 
MooseApp & _pg_moose_app
 
const std::string _prefix
 
const Parallel::Communicator & _communicator
 

Detailed Description

Implementation of Semi-Implicit Method for Pressure-Linked Equations (SIMPLE) with MOOSE-based applications.

It is a slightly restricted version of the PIMPLE algorithm: (i) no PISO iterations are allowed, (ii) no time kernels are allowed.

Definition at line 21 of file SIMPLESolve.h.

Constructor & Destructor Documentation

◆ SIMPLESolve()

SIMPLESolve::SIMPLESolve ( Executioner &  ex)

Definition at line 24 of file SIMPLESolve.C.

24 : LinearAssemblySegregatedSolve(ex) {}

Member Function Documentation

◆ checkDependentParameterError()

void SIMPLESolveBase::checkDependentParameterError ( const std::string &  main_parameter,
const std::vector< std::string > &  dependent_parameters,
const bool  should_be_defined 
)
protectedinherited

Definition at line 707 of file SIMPLESolveBase.C.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly().

710 {
711  for (const auto & param : dependent_parameters)
712  if (parameters().isParamSetByUser(param) == !should_be_defined)
713  paramError(param,
714  "This parameter should " + std::string(should_be_defined ? "" : "not") +
715  " be given by the user with the corresponding " + main_parameter +
716  " setting!");
717 }
SolveObject::paramError
void paramError(const std::string &param, Args... args) const
SolveObject::parameters
const InputParameters & parameters() const
SolveObject::isParamSetByUser
bool isParamSetByUser(const std::string &name) const

◆ checkIntegrity()

void SIMPLESolve::checkIntegrity ( )
overridevirtual

Check if the user defined time kernels, if yes error out.

Reimplemented from SIMPLESolveBase.

Definition at line 37 of file SIMPLESolve.C.

Referenced by SIMPLE::init().

38 {
39  // check to make sure that we don't have any time kernels in this simulation (Steady State)
40  if (_should_solve_momentum)
41  for (const auto system : _momentum_systems)
42  checkTimeKernels(*system);
43 
44  if (_should_solve_pressure)
45  checkTimeKernels(_pressure_system);
46 
47  if (_has_energy_system && _should_solve_energy)
48  checkTimeKernels(*_energy_system);
49 
50  if (_has_turbulence_systems && _should_solve_turbulence)
51  for (const auto system : _turbulence_systems)
52  checkTimeKernels(*system);
53 
54  if (_has_passive_scalar_systems && _should_solve_passive_scalars)
55  for (const auto system : _passive_scalar_systems)
56  checkTimeKernels(*system);
57 
58  if (_has_active_scalar_systems && _should_solve_active_scalars)
59  for (const auto system : _active_scalar_systems)
60  checkTimeKernels(*system);
61  if (_has_pm_radiation_systems)
62  for (const auto system : _pm_radiation_systems)
63  checkTimeKernels(*system);
64 }
SIMPLESolveBase::_has_energy_system
const bool _has_energy_system
Boolean for easy check if a fluid energy system shall be solved or not.
Definition: SIMPLESolveBase.h:127
LinearAssemblySegregatedSolve::_passive_scalar_systems
std::vector< LinearSystem * > _passive_scalar_systems
Pointer(s) to the system(s) corresponding to the passive scalar equation(s)
Definition: LinearAssemblySegregatedSolve.h:134
SIMPLESolveBase::_has_turbulence_systems
const bool _has_turbulence_systems
Boolean for easy check if a turbulence scalar systems shall be solved or not.
Definition: SIMPLESolveBase.h:211
LinearAssemblySegregatedSolve::_has_active_scalar_systems
const bool _has_active_scalar_systems
Boolean for easy check if a active scalar systems shall be solved or not.
Definition: LinearAssemblySegregatedSolve.h:167
LinearAssemblySegregatedSolve::_active_scalar_systems
std::vector< LinearSystem * > _active_scalar_systems
Pointer(s) to the system(s) corresponding to the active scalar equation(s)
Definition: LinearAssemblySegregatedSolve.h:140
LinearAssemblySegregatedSolve::_pressure_system
LinearSystem & _pressure_system
Reference to the linear system corresponding to the pressure equation.
Definition: LinearAssemblySegregatedSolve.h:119
LinearAssemblySegregatedSolve::_energy_system
LinearSystem * _energy_system
Pointer to the linear system corresponding to the fluid energy equation.
Definition: LinearAssemblySegregatedSolve.h:125
SIMPLESolveBase::_has_pm_radiation_systems
const bool _has_pm_radiation_systems
Boolean for easy check if participating media radiation systems shall be solved or not...
Definition: SIMPLESolveBase.h:187
SIMPLESolve::checkTimeKernels
virtual void checkTimeKernels(LinearSystem &system)
Check if the system contains time kernels.
Definition: SIMPLESolve.C:27
LinearAssemblySegregatedSolve::_turbulence_systems
std::vector< LinearSystem * > _turbulence_systems
Pointer(s) to the system(s) corresponding to the turbulence equation(s)
Definition: LinearAssemblySegregatedSolve.h:143
SIMPLESolveBase::_has_passive_scalar_systems
const bool _has_passive_scalar_systems
Boolean for easy check if a passive scalar systems shall be solved or not.
Definition: SIMPLESolveBase.h:163
LinearAssemblySegregatedSolve::_momentum_systems
std::vector< LinearSystem * > _momentum_systems
Pointer(s) to the system(s) corresponding to the momentum equation(s)
Definition: LinearAssemblySegregatedSolve.h:113
LinearAssemblySegregatedSolve::_should_solve_momentum
const bool _should_solve_momentum
Flags controlling which systems are actively solved (can be used with restart to freeze flow) ...
Definition: LinearAssemblySegregatedSolve.h:152
LinearAssemblySegregatedSolve::_pm_radiation_systems
std::vector< LinearSystem * > _pm_radiation_systems
Pointer(s) to the system(s) corresponding to the participting media radiation equation(s) ...
Definition: LinearAssemblySegregatedSolve.h:137

◆ checkTimeKernels()

void SIMPLESolve::checkTimeKernels ( LinearSystem &  system)
protectedvirtual

Check if the system contains time kernels.

Definition at line 27 of file SIMPLESolve.C.

Referenced by checkIntegrity().

28 {
29  // check to make sure that we don't have any time kernels in this simulation (Steady State)
30  if (system.containsTimeKernel())
31  mooseError("You have specified time kernels in your steady state simulation in system",
32  system.name(),
33  ", SIMPLE is a steady-state solver! Use the PIMPLE executioner instead.");
34 }
LinearSystem::containsTimeKernel
virtual bool containsTimeKernel() override
LinearSystem::name
virtual const std::string & name() const
SolveObject::mooseError
void mooseError(Args &&... args) const

◆ correctVelocity()

std::pair< unsigned int, Real > LinearAssemblySegregatedSolve::correctVelocity ( const bool  subtract_updated_pressure,
const bool  recompute_face_mass_flux,
const SolverParams &  solver_params 
)
protectedvirtualinherited

Computes new velocity field based on computed pressure gradients.

Parameters
subtract_updated_pressureIf we need to subtract the updated pressure gradient from the right hand side of the system
recompute_face_mass_fluxIf we want to recompute the face flux too
solver_paramsDummy solver parameter object for the linear solve

Reimplemented in PIMPLESolve.

Definition at line 506 of file LinearAssemblySegregatedSolve.C.

Referenced by PIMPLESolve::correctVelocity(), and LinearAssemblySegregatedSolve::solve().

509 {
510  // Compute the coupling fields between the momentum and pressure equations.
511  // The first argument makes sure the pressure gradient is staged at the first
512  // iteration
513  _rc_uo->computeHbyA(subtract_updated_pressure, _print_fields);
514 
515  // We set the preconditioner/controllable parameters for the pressure equations through
516  // petsc options. Linear tolerances will be overridden within the solver.
517  Moose::PetscSupport::petscSetOptions(_pressure_petsc_options, solver_params);
518 
519  // Solve the pressure corrector
520  const auto residuals = solvePressureCorrector();
521 
522  // Compute the face velocity which is used in the advection terms. In certain
523  // segregated solver algorithms (like PISO) this is only done on the last iteration.
524  if (recompute_face_mass_flux)
525  _rc_uo->computeFaceMassFlux();
526 
527  auto & pressure_current_solution = *(_pressure_system.system().current_local_solution.get());
528  auto & pressure_old_solution = *(_pressure_system.solutionPreviousNewton());
529 
530  // Relax the pressure update for the next momentum predictor
531  NS::FV::relaxSolutionUpdate(
532  pressure_current_solution, pressure_old_solution, _pressure_variable_relaxation);
533 
534  // Overwrite old solution
535  pressure_old_solution = pressure_current_solution;
536  _pressure_system.setSolution(pressure_current_solution);
537 
538  // We recompute the updated pressure gradient
539  _pressure_system.computeGradients();
540 
541  // Reconstruct the cell velocity as well to accelerate convergence
542  _rc_uo->computeCellVelocity();
543 
544  return residuals;
545 }
SIMPLESolveBase::_print_fields
const bool _print_fields
Debug parameter which allows printing the coupling and solution vectors/matrices. ...
Definition: SIMPLESolveBase.h:267
RhieChowMassFlux::computeFaceMassFlux
void computeFaceMassFlux()
Update the values of the face velocities in the containers.
Definition: RhieChowMassFlux.C:323
LinearSystem::setSolution
void setSolution(const NumericVector< Number > &soln)
LinearAssemblySegregatedSolve::_rc_uo
RhieChowMassFlux * _rc_uo
Pointer to the segregated RhieChow interpolation object.
Definition: LinearAssemblySegregatedSolve.h:146
LinearSystem::computeGradients
void computeGradients()
SIMPLESolveBase::_pressure_variable_relaxation
const Real _pressure_variable_relaxation
The user-defined relaxation parameter for the pressure variable.
Definition: SIMPLESolveBase.h:113
RhieChowMassFlux::computeHbyA
void computeHbyA(const bool with_updated_pressure, const bool verbose)
Computes the inverse of the diagonal (1/A) of the system matrix plus the H/A components for the press...
Definition: RhieChowMassFlux.C:541
LinearAssemblySegregatedSolve::_pressure_system
LinearSystem & _pressure_system
Reference to the linear system corresponding to the pressure equation.
Definition: LinearAssemblySegregatedSolve.h:119
RhieChowMassFlux::computeCellVelocity
void computeCellVelocity()
Update the cell values of the velocity variables.
Definition: RhieChowMassFlux.C:393
Moose::PetscSupport::petscSetOptions
void petscSetOptions(const PetscOptions &po, const SolverParams &solver_params, FEProblemBase *const problem=nullptr)
LinearAssemblySegregatedSolve::solvePressureCorrector
virtual std::pair< unsigned int, Real > solvePressureCorrector() override
Solve a pressure corrector step.
Definition: LinearAssemblySegregatedSolve.C:382
libMesh::System::current_local_solution
std::unique_ptr< NumericVector< Number > > current_local_solution
LinearSystem::solutionPreviousNewton
virtual const NumericVector< Number > * solutionPreviousNewton() const
NS::FV::relaxSolutionUpdate
void relaxSolutionUpdate(NumericVector< Number > &vec_new, const NumericVector< Number > &vec_old, const Real relaxation_factor)
Relax the update on a solution field using the following approach: $u = u_{old}+ (u - u_{old})$...
Definition: SegregatedSolverUtils.C:112
SIMPLESolveBase::_pressure_petsc_options
Moose::PetscSupport::PetscOptions _pressure_petsc_options
Options which hold the petsc settings for the pressure equation.
Definition: SIMPLESolveBase.h:110
LinearSystem::system
virtual System & system() override

◆ initialSetup()

void LinearAssemblySegregatedSolve::initialSetup ( )
overridevirtualinherited

Reimplemented from SolveObject.

Definition at line 372 of file LinearAssemblySegregatedSolve.C.

Referenced by SIMPLE::init(), and PIMPLE::init().

373 {
374  if (_cht.enabled())
375  {
376  _cht.deduceCHTBoundaryCoupling();
377  _cht.setupConjugateHeatTransferContainers();
378  }
379 }
NS::FV::CHTHandler::setupConjugateHeatTransferContainers
void setupConjugateHeatTransferContainers()
Set up the boundary condition pairs, functor maps, and every other necessary structure for the conjug...
Definition: CHTHandler.C:291
NS::FV::CHTHandler::deduceCHTBoundaryCoupling
void deduceCHTBoundaryCoupling()
Run error checks and make sure everything works.
Definition: CHTHandler.C:106
NS::FV::CHTHandler::enabled
virtual bool enabled() const override final
Check if CHT treatment is needed.
Definition: CHTHandler.h:152
LinearAssemblySegregatedSolve::_cht
NS::FV::CHTHandler _cht
********************** Conjugate heat transfer variables ************** //
Definition: LinearAssemblySegregatedSolve.h:191

◆ linkRhieChowUserObject()

void LinearAssemblySegregatedSolve::linkRhieChowUserObject ( )
overridevirtualinherited

Fetch the Rhie Chow user object that is reponsible for determining face velocities and mass flux.

Implements SIMPLESolveBase.

Definition at line 258 of file LinearAssemblySegregatedSolve.C.

Referenced by SIMPLE::init(), and PIMPLE::init().

259 {
260  if (!_should_solve_momentum)
261  return;
262 
263  _rc_uo =
264  const_cast<RhieChowMassFlux *>(&getUserObject<RhieChowMassFlux>("rhie_chow_user_object"));
265  _rc_uo->linkMomentumPressureSystems(
266  _momentum_systems, _pressure_system, _momentum_system_numbers);
267 
268  // Initialize the face velocities in the RC object
269  if (!_app.isRecovering())
270  _rc_uo->initFaceMassFlux();
271  _rc_uo->initCouplingField();
272 }
RhieChowMassFlux
User object responsible for determining the face fluxes using the Rhie-Chow interpolation in a segreg...
Definition: RhieChowMassFlux.h:37
LinearAssemblySegregatedSolve::_rc_uo
RhieChowMassFlux * _rc_uo
Pointer to the segregated RhieChow interpolation object.
Definition: LinearAssemblySegregatedSolve.h:146
LinearAssemblySegregatedSolve::_pressure_system
LinearSystem & _pressure_system
Reference to the linear system corresponding to the pressure equation.
Definition: LinearAssemblySegregatedSolve.h:119
LinearAssemblySegregatedSolve::_momentum_system_numbers
std::vector< unsigned int > _momentum_system_numbers
The number(s) of the system(s) corresponding to the momentum equation(s)
Definition: LinearAssemblySegregatedSolve.h:110
RhieChowMassFlux::linkMomentumPressureSystems
void linkMomentumPressureSystems(const std::vector< LinearSystem *> &momentum_systems, const LinearSystem &pressure_system, const std::vector< unsigned int > &momentum_system_numbers)
Update the momentum system-related information.
Definition: RhieChowMassFlux.C:117
SolveObject::_app
MooseApp & _app
LinearAssemblySegregatedSolve::_momentum_systems
std::vector< LinearSystem * > _momentum_systems
Pointer(s) to the system(s) corresponding to the momentum equation(s)
Definition: LinearAssemblySegregatedSolve.h:113
MooseApp::isRecovering
bool isRecovering() const
LinearAssemblySegregatedSolve::_should_solve_momentum
const bool _should_solve_momentum
Flags controlling which systems are actively solved (can be used with restart to freeze flow) ...
Definition: LinearAssemblySegregatedSolve.h:152
RhieChowMassFlux::initCouplingField
void initCouplingField()
Initialize the coupling fields (HbyA and Ainv)
Definition: RhieChowMassFlux.C:413
RhieChowMassFlux::initFaceMassFlux
void initFaceMassFlux()
Initialize the container for face velocities.
Definition: RhieChowMassFlux.C:236

◆ setInnerSolve()

virtual void SIMPLESolveBase::setInnerSolve ( SolveObject &  )
inlineoverridevirtualinherited

Reimplemented from SolveObject.

Definition at line 48 of file SIMPLESolveBase.h.

49  {
50  mooseError("Cannot set inner solve object for solves that inherit from SIMPLESolveBase");
51  }
SolveObject::mooseError
void mooseError(Args &&... args) const

◆ setupPressurePin()

void SIMPLESolveBase::setupPressurePin ( )
inherited

Setup pressure pin if there is need for one.

Definition at line 698 of file SIMPLESolveBase.C.

Referenced by SIMPLE::init(), SIMPLENonlinearAssembly::init(), and PIMPLE::init().

699 {
700  if (_pin_pressure)
701  _pressure_pin_dof = NS::FV::findPointDoFID(_problem.getVariable(0, "pressure"),
702  _problem.mesh(),
703  getParam<Point>("pressure_pin_point"));
704 }
SolveObject::_problem
FEProblemBase & _problem
FEProblemBase::getVariable
virtual const MooseVariableFieldBase & getVariable(const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override
SIMPLESolveBase::_pressure_pin_dof
dof_id_type _pressure_pin_dof
The dof ID where the pressure needs to be pinned.
Definition: SIMPLESolveBase.h:122
SIMPLESolveBase::_pin_pressure
const bool _pin_pressure
If the pressure needs to be pinned.
Definition: SIMPLESolveBase.h:116
NS::FV::findPointDoFID
dof_id_type findPointDoFID(const MooseVariableFieldBase &variable, const MooseMesh &mesh, const Point &point)
Find the ID of the degree of freedom which corresponds to the variable and a given point on the mesh...
Definition: SegregatedSolverUtils.C:197
FEProblemBase::mesh
virtual MooseMesh & mesh() override

◆ setupResidualStorage()

LinearAssemblySegregatedSolve::ResidualStorage LinearAssemblySegregatedSolve::setupResidualStorage ( ) const
protectedinherited

Build residual/tolerance vectors and associated indices for all enabled systems.

Definition at line 855 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::solve().

856 {
857  ResidualStorage storage;
858 
859  // Residual store: position in this vector defines the ordering used by NS::FV::converged()
860  // Each entry holds (linear its, normalized residual) for one system
861  if (_should_solve_momentum)
862  for ([[maybe_unused]] const auto system_i : index_range(_momentum_systems))
863  {
864  storage.momentum_indices.push_back(storage.ns_residuals.size());
865  storage.ns_residuals.push_back(std::make_pair(0, 1.0));
866  storage.ns_abs_tols.push_back(_momentum_absolute_tolerance);
867  }
868 
869  if (_should_solve_pressure)
870  {
871  storage.pressure_index = storage.ns_residuals.size();
872  storage.ns_residuals.push_back(std::make_pair(0, 1.0));
873  storage.ns_abs_tols.push_back(_pressure_absolute_tolerance);
874  }
875 
876  if (_has_energy_system && _should_solve_energy)
877  {
878  storage.energy_index = storage.ns_residuals.size();
879  storage.ns_residuals.push_back(std::make_pair(0, 1.0));
880  storage.ns_abs_tols.push_back(_energy_absolute_tolerance);
881  }
882 
883  if (_has_solid_energy_system && _should_solve_solid_energy)
884  {
885  storage.solid_energy_index = storage.ns_residuals.size();
886  storage.ns_residuals.push_back(std::make_pair(0, 1.0));
887  storage.ns_abs_tols.push_back(_solid_energy_absolute_tolerance);
888  }
889 
890  if (_has_active_scalar_systems && _should_solve_active_scalars)
891  for (const auto i : index_range(_active_scalar_system_names))
892  {
893  storage.active_scalar_indices.push_back(storage.ns_residuals.size());
894  storage.ns_residuals.push_back(std::make_pair(0, 1.0));
895  storage.ns_abs_tols.push_back(_active_scalar_absolute_tolerance[i]);
896  }
897 
898  if (_has_turbulence_systems && _should_solve_turbulence)
899  for (const auto i : index_range(_turbulence_system_names))
900  {
901  storage.turbulence_indices.push_back(storage.ns_residuals.size());
902  storage.ns_residuals.push_back(std::make_pair(0, 1.0));
903  storage.ns_abs_tols.push_back(_turbulence_absolute_tolerance[i]);
904  }
905 
906  if (_has_pm_radiation_systems && _should_solve_pm_radiation)
907  for (const auto i : index_range(_pm_radiation_system_names))
908  {
909  storage.pm_radiation_indices.push_back(storage.ns_residuals.size());
910  storage.ns_residuals.push_back(std::make_pair(0, 1.0));
911  storage.ns_abs_tols.push_back(_pm_radiation_absolute_tolerance[i]);
912  }
913 
914  storage.converged = storage.ns_residuals.empty();
915  return storage;
916 }
SIMPLESolveBase::_energy_absolute_tolerance
const Real _energy_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in energy.
Definition: SIMPLESolveBase.h:244
SIMPLESolveBase::_has_energy_system
const bool _has_energy_system
Boolean for easy check if a fluid energy system shall be solved or not.
Definition: SIMPLESolveBase.h:127
SIMPLESolveBase::_has_turbulence_systems
const bool _has_turbulence_systems
Boolean for easy check if a turbulence scalar systems shall be solved or not.
Definition: SIMPLESolveBase.h:211
LinearAssemblySegregatedSolve::_has_active_scalar_systems
const bool _has_active_scalar_systems
Boolean for easy check if a active scalar systems shall be solved or not.
Definition: LinearAssemblySegregatedSolve.h:167
SIMPLESolveBase::_pressure_absolute_tolerance
const Real _pressure_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in pressure.
Definition: SIMPLESolveBase.h:241
SIMPLESolveBase::_momentum_absolute_tolerance
const Real _momentum_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in momentum.
Definition: SIMPLESolveBase.h:238
SIMPLESolveBase::_pm_radiation_system_names
const std::vector< SolverSystemName > & _pm_radiation_system_names
The names of the participating media radiation systems.
Definition: SIMPLESolveBase.h:184
SIMPLESolveBase::_has_pm_radiation_systems
const bool _has_pm_radiation_systems
Boolean for easy check if participating media radiation systems shall be solved or not...
Definition: SIMPLESolveBase.h:187
SIMPLESolveBase::_turbulence_system_names
const std::vector< SolverSystemName > & _turbulence_system_names
The names of the turbulence systems.
Definition: SIMPLESolveBase.h:208
SIMPLESolveBase::_pm_radiation_absolute_tolerance
const std::vector< Real > _pm_radiation_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in participating media radiation...
Definition: SIMPLESolveBase.h:253
LinearAssemblySegregatedSolve::_active_scalar_system_names
const std::vector< SolverSystemName > & _active_scalar_system_names
The names of the active scalar systems.
Definition: LinearAssemblySegregatedSolve.h:164
LinearAssemblySegregatedSolve::_active_scalar_absolute_tolerance
const std::vector< Real > _active_scalar_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in active scalars.
Definition: LinearAssemblySegregatedSolve.h:186
SIMPLESolveBase::_solid_energy_absolute_tolerance
const Real _solid_energy_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in solid energy.
Definition: SIMPLESolveBase.h:247
LinearAssemblySegregatedSolve::_momentum_systems
std::vector< LinearSystem * > _momentum_systems
Pointer(s) to the system(s) corresponding to the momentum equation(s)
Definition: LinearAssemblySegregatedSolve.h:113
SIMPLESolveBase::_turbulence_absolute_tolerance
const std::vector< Real > _turbulence_absolute_tolerance
The user-defined absolute tolerance for determining the convergence turbulence variables.
Definition: SIMPLESolveBase.h:256
LinearAssemblySegregatedSolve::_should_solve_momentum
const bool _should_solve_momentum
Flags controlling which systems are actively solved (can be used with restart to freeze flow) ...
Definition: LinearAssemblySegregatedSolve.h:152
index_range
auto index_range(const T &sizable)
SIMPLESolveBase::_has_solid_energy_system
const bool _has_solid_energy_system
Boolean for easy check if a solid energy system shall be solved or not.
Definition: SIMPLESolveBase.h:145

◆ solve()

bool LinearAssemblySegregatedSolve::solve ( )
overridevirtualinherited

Performs the momentum pressure coupling.

Returns
True if solver is converged.

Implements SolveObject.

Definition at line 635 of file LinearAssemblySegregatedSolve.C.

636 {
637  // Do not solve if problem is set not to
638  if (!_problem.shouldSolve())
639  return true;
640 
641  // Dummy solver parameter file which is needed for switching petsc options
642  SolverParams solver_params;
643  solver_params._type = Moose::SolveType::ST_LINEAR;
644  solver_params._line_search = Moose::LineSearchType::LS_NONE;
645 
646  // Initialize the SIMPLE iteration counter
647  unsigned int simple_iteration_counter = 0;
648 
649  // We set up the residual storage and the corresponding tolerances.
650  ResidualStorage residual_storage = setupResidualStorage();
651  auto & ns_residuals = residual_storage.ns_residuals;
652  auto & ns_abs_tols = residual_storage.ns_abs_tols;
653  const auto & momentum_indices = residual_storage.momentum_indices;
654  const auto pressure_index = residual_storage.pressure_index;
655  const auto energy_index = residual_storage.energy_index;
656  const auto solid_energy_index = residual_storage.solid_energy_index;
657  const auto & active_scalar_indices = residual_storage.active_scalar_indices;
658  const auto & turbulence_indices = residual_storage.turbulence_indices;
659  const auto & pm_radiation_indices = residual_storage.pm_radiation_indices;
660 
661  bool converged = residual_storage.converged;
662 
663  // Loop until converged or hit the maximum allowed iteration number
664  if (_cht.enabled() && _should_solve_energy)
665  _cht.initializeCHTCouplingFields();
666 
667  while (simple_iteration_counter < _num_iterations && !converged)
668  {
669  simple_iteration_counter++;
670 
671  // We set the preconditioner/controllable parameters through petsc options. Linear
672  // tolerances will be overridden within the solver. In case of a segregated momentum
673  // solver, we assume that every velocity component uses the same preconditioner
674  if (_should_solve_momentum)
675  Moose::PetscSupport::petscSetOptions(_momentum_petsc_options, solver_params);
676 
677  // Initialize pressure gradients, after this we just reuse the last ones from each
678  // iteration
679  if (_should_solve_pressure && simple_iteration_counter == 1)
680  _pressure_system.computeGradients();
681 
682  _console << "Iteration " << simple_iteration_counter << " Initial residual norms:" << std::endl;
683 
684  // Solve the momentum predictor step
685  if (_should_solve_momentum)
686  {
687  auto momentum_residual = solveMomentumPredictor();
688  for (const auto system_i : index_range(momentum_residual))
689  ns_residuals[momentum_indices[system_i]] = momentum_residual[system_i];
690  }
691 
692  // Now we correct the velocity, this function depends on the method, it differs for
693  // SIMPLE/PIMPLE, this returns the pressure errors
694  if (_should_solve_pressure)
695  ns_residuals[pressure_index] = correctVelocity(true, true, solver_params);
696 
697  // If we have an energy equation, solve it here.We assume the material properties in the
698  // Navier-Stokes equations depend on temperature, therefore we can not solve for temperature
699  // outside of the velocity-pressure loop
700  if (_has_energy_system && _should_solve_energy)
701  {
702  // If there is no CHT specified this will just do go once through this block
703  _cht.resetCHTConvergence();
704  while (!_cht.converged())
705  {
706  if (_cht.enabled())
707  _cht.updateCHTBoundaryCouplingFields(NS::CHTSide::FLUID);
708 
709  // We set the preconditioner/controllable parameters through petsc options. Linear
710  // tolerances will be overridden within the solver.
711  Moose::PetscSupport::petscSetOptions(_energy_petsc_options, solver_params);
712  ns_residuals[energy_index] = solveAdvectedSystem(_energy_sys_number,
713  *_energy_system,
714  _energy_equation_relaxation,
715  _energy_linear_control,
716  _energy_l_abs_tol);
717 
718  if (_has_pm_radiation_systems && _should_solve_pm_radiation)
719  {
720  // We set the preconditioner/controllable parameters through petsc options. Linear
721  // tolerances will be overridden within the solver.
722  Moose::PetscSupport::petscSetOptions(_pm_radiation_petsc_options, solver_params);
723  for (const auto i : index_range(_pm_radiation_system_names))
724  {
725  ns_residuals[pm_radiation_indices[i]] =
726  solveAdvectedSystem(_pm_radiation_system_numbers[i],
727  *_pm_radiation_systems[i],
728  _pm_radiation_equation_relaxation[i],
729  _pm_radiation_linear_control,
730  _pm_radiation_l_abs_tol);
731  }
732  }
733 
734  if (_has_solid_energy_system && _should_solve_solid_energy)
735  {
736  // For now we only update gradients if cht is needed, might change in the future
737  if (_cht.enabled())
738  {
739  _energy_system->computeGradients();
740  _cht.updateCHTBoundaryCouplingFields(NS::CHTSide::SOLID);
741  }
742 
743  // We set the preconditioner/controllable parameters through petsc options. Linear
744  // tolerances will be overridden within the solver.
745  Moose::PetscSupport::petscSetOptions(_solid_energy_petsc_options, solver_params);
746  ns_residuals[solid_energy_index] = solveSolidEnergy();
747 
748  // For now we only update gradients if cht is needed, might change in the future
749  if (_cht.enabled())
750  _solid_energy_system->computeGradients();
751  }
752 
753  if (_cht.enabled())
754  {
755  _cht.sumIntegratedFluxes();
756  _cht.printIntegratedFluxes();
757  }
758 
759  _cht.incrementCHTIterators();
760  }
761  if (_cht.enabled())
762  _cht.resetIntegratedFluxes();
763  }
764 
765  // If we have active scalar equations, solve them here in case they depend on temperature
766  // or they affect the fluid properties such that they must be solved concurrently with
767  // pressure and velocity
768  if (_has_active_scalar_systems && _should_solve_active_scalars)
769  {
770  _problem.execute(EXEC_NONLINEAR);
771 
772  // We set the preconditioner/controllable parameters through petsc options. Linear
773  // tolerances will be overridden within the solver.
774  Moose::PetscSupport::petscSetOptions(_active_scalar_petsc_options, solver_params);
775  for (const auto i : index_range(_active_scalar_system_names))
776  ns_residuals[active_scalar_indices[i]] =
777  solveAdvectedSystem(_active_scalar_system_numbers[i],
778  *_active_scalar_systems[i],
779  _active_scalar_equation_relaxation[i],
780  _active_scalar_linear_control,
781  _active_scalar_l_abs_tol);
782  }
783 
784  // If we have turbulence equations, solve them here.
785  // The turbulent viscosity depends on the value of the turbulence surrogate variables
786  if (_has_turbulence_systems && _should_solve_turbulence)
787  {
788  // We set the preconditioner/controllable parameters through petsc options. Linear
789  // tolerances will be overridden within the solver.
790  Moose::PetscSupport::petscSetOptions(_turbulence_petsc_options, solver_params);
791  for (const auto i : index_range(_turbulence_system_names))
792  {
793  ns_residuals[turbulence_indices[i]] =
794  solveAdvectedSystem(_turbulence_system_numbers[i],
795  *_turbulence_systems[i],
796  _turbulence_equation_relaxation[i],
797  _turbulence_linear_control,
798  _turbulence_l_abs_tol,
799  _turbulence_field_relaxation[i],
800  _turbulence_field_min_limit[i]);
801  }
802  }
803 
804  _problem.execute(EXEC_NONLINEAR);
805 
806  converged = NS::FV::converged(ns_residuals, ns_abs_tols);
807  }
808 
809  // If we have passive scalar equations, solve them here. We assume the material properties in
810  // the Navier-Stokes equations do not depend on passive scalars, as they are passive, therefore
811  // we solve outside of the velocity-pressure loop
812  if (_has_passive_scalar_systems && _should_solve_passive_scalars &&
813  (converged || _continue_on_max_its))
814  {
815  // The reason why we need more than one iteration is due to the matrix relaxation
816  // which can be used to stabilize the equations
817  bool passive_scalar_converged = false;
818  unsigned int ps_iteration_counter = 0;
819 
820  _console << "Passive scalar iteration " << ps_iteration_counter
821  << " Initial residual norms:" << std::endl;
822 
823  while (ps_iteration_counter < _num_iterations && !passive_scalar_converged)
824  {
825  ps_iteration_counter++;
826  std::vector<std::pair<unsigned int, Real>> scalar_residuals(
827  _passive_scalar_system_names.size(), std::make_pair(0, 1.0));
828  std::vector<Real> scalar_abs_tols;
829  for (const auto scalar_tol : _passive_scalar_absolute_tolerance)
830  scalar_abs_tols.push_back(scalar_tol);
831 
832  // We set the preconditioner/controllable parameters through petsc options. Linear
833  // tolerances will be overridden within the solver.
834  Moose::PetscSupport::petscSetOptions(_passive_scalar_petsc_options, solver_params);
835  for (const auto i : index_range(_passive_scalar_system_names))
836  scalar_residuals[i] = solveAdvectedSystem(_passive_scalar_system_numbers[i],
837  *_passive_scalar_systems[i],
838  _passive_scalar_equation_relaxation[i],
839  _passive_scalar_linear_control,
840  _passive_scalar_l_abs_tol);
841 
842  passive_scalar_converged = NS::FV::converged(scalar_residuals, scalar_abs_tols);
843  }
844 
845  // Both flow and scalars must converge
846  converged = passive_scalar_converged && converged;
847  }
848 
849  converged = _continue_on_max_its ? true : converged;
850 
851  return converged;
852 }
FEProblemBase::shouldSolve
bool shouldSolve() const
LinearAssemblySegregatedSolve::_active_scalar_equation_relaxation
const std::vector< Real > _active_scalar_equation_relaxation
The user-defined relaxation parameter(s) for the active scalar equation(s)
Definition: LinearAssemblySegregatedSolve.h:173
SolveObject::_problem
FEProblemBase & _problem
SIMPLESolveBase::_turbulence_linear_control
SIMPLESolverConfiguration _turbulence_linear_control
Options for the linear solver of the turbulence equation(s)
Definition: SIMPLESolveBase.h:229
NS::FV::CHTHandler::updateCHTBoundaryCouplingFields
void updateCHTBoundaryCouplingFields(const NS::CHTSide side)
Update the coupling fields for.
Definition: CHTHandler.C:392
SIMPLESolveBase::_num_iterations
const unsigned int _num_iterations
The maximum number of momentum-pressure iterations.
Definition: SIMPLESolveBase.h:259
SIMPLESolveBase::_energy_linear_control
SIMPLESolverConfiguration _energy_linear_control
Options for the linear solver of the energy equation.
Definition: SIMPLESolveBase.h:136
SIMPLESolveBase::_turbulence_petsc_options
Moose::PetscSupport::PetscOptions _turbulence_petsc_options
Options which hold the petsc settings for the turbulence equation(s)
Definition: SIMPLESolveBase.h:226
SIMPLESolveBase::_pm_radiation_linear_control
SIMPLESolverConfiguration _pm_radiation_linear_control
Options for the linear solver of the participating media radiation equation(s)
Definition: SIMPLESolveBase.h:199
SIMPLESolveBase::_has_energy_system
const bool _has_energy_system
Boolean for easy check if a fluid energy system shall be solved or not.
Definition: SIMPLESolveBase.h:127
SolverParams::_line_search
Moose::LineSearchType _line_search
LinearAssemblySegregatedSolve::_active_scalar_linear_control
SIMPLESolverConfiguration _active_scalar_linear_control
Options for the linear solver of the active scalar equation(s)
Definition: LinearAssemblySegregatedSolve.h:179
SIMPLESolveBase::_turbulence_field_relaxation
std::vector< Real > _turbulence_field_relaxation
The user-defined relaxation parameter(s) for the turbulence field(s)
Definition: SIMPLESolveBase.h:220
SIMPLESolveBase::_passive_scalar_l_abs_tol
const Real _passive_scalar_l_abs_tol
Absolute linear tolerance for the passive scalar equation(s).
Definition: SIMPLESolveBase.h:179
LinearAssemblySegregatedSolve::solveSolidEnergy
std::pair< unsigned int, Real > solveSolidEnergy()
Solve an equation which contains the solid energy conservation.
Definition: LinearAssemblySegregatedSolve.C:446
LinearAssemblySegregatedSolve::_passive_scalar_systems
std::vector< LinearSystem * > _passive_scalar_systems
Pointer(s) to the system(s) corresponding to the passive scalar equation(s)
Definition: LinearAssemblySegregatedSolve.h:134
NS::FV::CHTHandler::resetIntegratedFluxes
void resetIntegratedFluxes()
Reset the heat fluxes to 0.
Definition: CHTHandler.C:488
SIMPLESolveBase::_solid_energy_petsc_options
Moose::PetscSupport::PetscOptions _solid_energy_petsc_options
Options which hold the petsc settings for the fluid energy equation.
Definition: SIMPLESolveBase.h:148
SIMPLESolveBase::_has_turbulence_systems
const bool _has_turbulence_systems
Boolean for easy check if a turbulence scalar systems shall be solved or not.
Definition: SIMPLESolveBase.h:211
SIMPLESolveBase::_turbulence_system_numbers
std::vector< unsigned int > _turbulence_system_numbers
Definition: SIMPLESolveBase.h:214
NS::FV::CHTHandler::printIntegratedFluxes
void printIntegratedFluxes() const
Print the integrated heat fluxes.
Definition: CHTHandler.C:476
LinearAssemblySegregatedSolve::_solid_energy_system
LinearSystem * _solid_energy_system
Pointer to the linear system corresponding to the solid energy equation.
Definition: LinearAssemblySegregatedSolve.h:131
NS::FLUID
Definition: NS.h:201
LinearAssemblySegregatedSolve::solveAdvectedSystem
std::pair< unsigned int, Real > solveAdvectedSystem(const unsigned int system_num, LinearSystem &system, const Real relaxation_factor, libMesh::SolverConfiguration &solver_config, const Real abs_tol, const Real field_relaxation=1.0, const Real min_value_limiter=std::numeric_limits< Real >::min())
Solve an equation which contains an advection term that depends on the solution of the segregated Nav...
Definition: LinearAssemblySegregatedSolve.C:548
LinearAssemblySegregatedSolve::_has_active_scalar_systems
const bool _has_active_scalar_systems
Boolean for easy check if a active scalar systems shall be solved or not.
Definition: LinearAssemblySegregatedSolve.h:167
LinearAssemblySegregatedSolve::_active_scalar_l_abs_tol
const Real _active_scalar_l_abs_tol
Absolute linear tolerance for the active scalar equation(s).
Definition: LinearAssemblySegregatedSolve.h:183
NS::FV::CHTHandler::initializeCHTCouplingFields
void initializeCHTCouplingFields()
Initialize the coupling fields for the conjugate heat transfer routines.
Definition: CHTHandler.C:371
LinearAssemblySegregatedSolve::correctVelocity
virtual std::pair< unsigned int, Real > correctVelocity(const bool subtract_updated_pressure, const bool recompute_face_mass_flux, const SolverParams &solver_params)
Computes new velocity field based on computed pressure gradients.
Definition: LinearAssemblySegregatedSolve.C:506
SIMPLESolveBase::_pm_radiation_system_numbers
std::vector< unsigned int > _pm_radiation_system_numbers
Definition: SIMPLESolveBase.h:190
LinearSystem::computeGradients
void computeGradients()
NS::FV::CHTHandler::resetCHTConvergence
void resetCHTConvergence()
Reset the convergence data.
Definition: CHTHandler.h:158
NS::FV::converged
bool converged(const std::vector< std::pair< unsigned int, Real >> &residuals, const std::vector< Real > &abs_tolerances)
Based on the residuals, determine if the iterative process converged or not.
Definition: SegregatedSolverUtils.C:229
SIMPLESolveBase::_pm_radiation_system_names
const std::vector< SolverSystemName > & _pm_radiation_system_names
The names of the participating media radiation systems.
Definition: SIMPLESolveBase.h:184
SIMPLESolveBase::_passive_scalar_system_names
const std::vector< SolverSystemName > & _passive_scalar_system_names
The names of the passive scalar systems.
Definition: SIMPLESolveBase.h:160
LinearAssemblySegregatedSolve::_active_scalar_systems
std::vector< LinearSystem * > _active_scalar_systems
Pointer(s) to the system(s) corresponding to the active scalar equation(s)
Definition: LinearAssemblySegregatedSolve.h:140
SIMPLESolveBase::_passive_scalar_linear_control
SIMPLESolverConfiguration _passive_scalar_linear_control
Options for the linear solver of the passive scalar equation(s)
Definition: SIMPLESolveBase.h:175
FEProblemBase::execute
virtual void execute(const ExecFlagType &exec_type)
SIMPLESolveBase::_energy_petsc_options
Moose::PetscSupport::PetscOptions _energy_petsc_options
Options which hold the petsc settings for the fluid energy equation.
Definition: SIMPLESolveBase.h:133
LinearAssemblySegregatedSolve::_pressure_system
LinearSystem & _pressure_system
Reference to the linear system corresponding to the pressure equation.
Definition: LinearAssemblySegregatedSolve.h:119
LinearAssemblySegregatedSolve::_energy_system
LinearSystem * _energy_system
Pointer to the linear system corresponding to the fluid energy equation.
Definition: LinearAssemblySegregatedSolve.h:125
LinearAssemblySegregatedSolve::_energy_sys_number
const unsigned int _energy_sys_number
The number of the system corresponding to the energy equation.
Definition: LinearAssemblySegregatedSolve.h:122
NS::FV::CHTHandler::incrementCHTIterators
void incrementCHTIterators()
Increment CHT iterators in the loop.
Definition: CHTHandler.h:164
SIMPLESolveBase::_has_pm_radiation_systems
const bool _has_pm_radiation_systems
Boolean for easy check if participating media radiation systems shall be solved or not...
Definition: SIMPLESolveBase.h:187
SIMPLESolveBase::_passive_scalar_petsc_options
Moose::PetscSupport::PetscOptions _passive_scalar_petsc_options
Options which hold the petsc settings for the passive scalar equation(s)
Definition: SIMPLESolveBase.h:172
NS::FV::CHTHandler::converged
bool converged() const
Check if CHT iteration converged.
Definition: CHTHandler.C:495
LinearAssemblySegregatedSolve::setupResidualStorage
ResidualStorage setupResidualStorage() const
Build residual/tolerance vectors and associated indices for all enabled systems.
Definition: LinearAssemblySegregatedSolve.C:855
SIMPLESolveBase::_momentum_petsc_options
Moose::PetscSupport::PetscOptions _momentum_petsc_options
Options which hold the petsc settings for the momentum equation.
Definition: SIMPLESolveBase.h:92
SIMPLESolveBase::_passive_scalar_absolute_tolerance
const std::vector< Real > _passive_scalar_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in passive scalars.
Definition: SIMPLESolveBase.h:250
SolverParams::_type
Moose::SolveType _type
SIMPLESolveBase::_turbulence_system_names
const std::vector< SolverSystemName > & _turbulence_system_names
The names of the turbulence systems.
Definition: SIMPLESolveBase.h:208
SIMPLESolveBase::_pm_radiation_equation_relaxation
const std::vector< Real > _pm_radiation_equation_relaxation
The user-defined relaxation parameter(s) for the participating media radiation equation(s) ...
Definition: SIMPLESolveBase.h:193
SIMPLESolveBase::_energy_l_abs_tol
const Real _energy_l_abs_tol
Absolute linear tolerance for the energy equations.
Definition: SIMPLESolveBase.h:140
Moose::PetscSupport::petscSetOptions
void petscSetOptions(const PetscOptions &po, const SolverParams &solver_params, FEProblemBase *const problem=nullptr)
NS::FV::CHTHandler::sumIntegratedFluxes
void sumIntegratedFluxes()
Sum the integrated fluxes over all processors.
Definition: CHTHandler.C:465
SIMPLESolveBase::_turbulence_equation_relaxation
const std::vector< Real > _turbulence_equation_relaxation
The user-defined relaxation parameter(s) for the turbulence equation(s)
Definition: SIMPLESolveBase.h:217
LinearAssemblySegregatedSolve::_turbulence_systems
std::vector< LinearSystem * > _turbulence_systems
Pointer(s) to the system(s) corresponding to the turbulence equation(s)
Definition: LinearAssemblySegregatedSolve.h:143
SIMPLESolveBase::_pm_radiation_l_abs_tol
const Real _pm_radiation_l_abs_tol
Absolute linear tolerance for the participating media radiation equation(s).
Definition: SIMPLESolveBase.h:203
SIMPLESolveBase::_passive_scalar_equation_relaxation
const std::vector< Real > _passive_scalar_equation_relaxation
The user-defined relaxation parameter(s) for the passive scalar equation(s)
Definition: SIMPLESolveBase.h:169
LinearAssemblySegregatedSolve::_active_scalar_system_names
const std::vector< SolverSystemName > & _active_scalar_system_names
The names of the active scalar systems.
Definition: LinearAssemblySegregatedSolve.h:164
SIMPLESolveBase::_energy_equation_relaxation
const Real _energy_equation_relaxation
The user-defined relaxation parameter for the energy equation.
Definition: SIMPLESolveBase.h:130
LinearAssemblySegregatedSolve::solveMomentumPredictor
virtual std::vector< std::pair< unsigned int, Real > > solveMomentumPredictor() override
Solve a momentum predictor step with a fixed pressure field.
Definition: LinearAssemblySegregatedSolve.C:275
SIMPLESolveBase::_turbulence_l_abs_tol
const Real _turbulence_l_abs_tol
Absolute linear tolerance for the turbulence equation(s).
Definition: SIMPLESolveBase.h:233
LinearAssemblySegregatedSolve::_active_scalar_petsc_options
Moose::PetscSupport::PetscOptions _active_scalar_petsc_options
Options which hold the petsc settings for the active scalar equation(s)
Definition: LinearAssemblySegregatedSolve.h:176
SIMPLESolveBase::_has_passive_scalar_systems
const bool _has_passive_scalar_systems
Boolean for easy check if a passive scalar systems shall be solved or not.
Definition: SIMPLESolveBase.h:163
NS::FV::CHTHandler::enabled
virtual bool enabled() const override final
Check if CHT treatment is needed.
Definition: CHTHandler.h:152
SolveObject::_console
const ConsoleStream _console
LinearAssemblySegregatedSolve::_active_scalar_system_numbers
std::vector< unsigned int > _active_scalar_system_numbers
Definition: LinearAssemblySegregatedSolve.h:170
SIMPLESolveBase::_continue_on_max_its
const bool _continue_on_max_its
If solve should continue if maximum number of iterations is hit.
Definition: SIMPLESolveBase.h:262
SIMPLESolveBase::_pm_radiation_petsc_options
Moose::PetscSupport::PetscOptions _pm_radiation_petsc_options
Options which hold the petsc settings for the participating media radiation equation(s) ...
Definition: SIMPLESolveBase.h:196
SIMPLESolveBase::_turbulence_field_min_limit
std::vector< Real > _turbulence_field_min_limit
The user-defined lower limit for turbulent quantities e.g. k, eps/omega, etc..
Definition: SIMPLESolveBase.h:223
LinearAssemblySegregatedSolve::_should_solve_momentum
const bool _should_solve_momentum
Flags controlling which systems are actively solved (can be used with restart to freeze flow) ...
Definition: LinearAssemblySegregatedSolve.h:152
LinearAssemblySegregatedSolve::_pm_radiation_systems
std::vector< LinearSystem * > _pm_radiation_systems
Pointer(s) to the system(s) corresponding to the participting media radiation equation(s) ...
Definition: LinearAssemblySegregatedSolve.h:137
index_range
auto index_range(const T &sizable)
SIMPLESolveBase::_passive_scalar_system_numbers
std::vector< unsigned int > _passive_scalar_system_numbers
Definition: SIMPLESolveBase.h:166
LinearAssemblySegregatedSolve::_cht
NS::FV::CHTHandler _cht
********************** Conjugate heat transfer variables ************** //
Definition: LinearAssemblySegregatedSolve.h:191
NS::SOLID
Definition: NS.h:200
SIMPLESolveBase::_has_solid_energy_system
const bool _has_solid_energy_system
Boolean for easy check if a solid energy system shall be solved or not.
Definition: SIMPLESolveBase.h:145

◆ solveAdvectedSystem()

std::pair< unsigned int, Real > LinearAssemblySegregatedSolve::solveAdvectedSystem ( const unsigned int  system_num,
LinearSystem &  system,
const Real  relaxation_factor,
libMesh::SolverConfiguration &  solver_config,
const Real  abs_tol,
const Real  field_relaxation = 1.0,
const Real  min_value_limiter = std::numeric_limits<Real>::min() 
)
protectedinherited

Solve an equation which contains an advection term that depends on the solution of the segregated Navier-Stokes equations.

Parameters
system_numThe number of the system which is solved
systemReference to the system which is solved
relaxation_factorThe relaxation factor for matrix relaxation
solver_configThe solver configuration object for the linear solve
abs_tolThe scaled absolute tolerance for the linear solve
field_relaxation(optional) The relaxation factor for fields if relax_fields is true. Default value is 1.0.
min_value_limiter(optional) The minimum value for the solution field
Returns
The normalized residual norm of the equation.

Definition at line 548 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::solve().

555 {
556  _problem.setCurrentLinearSystem(system_num);
557 
558  // We will need some members from the implicit linear system
559  LinearImplicitSystem & li_system = libMesh::cast_ref<LinearImplicitSystem &>(system.system());
560 
561  // We will need the solution, the right hand side and the matrix
562  NumericVector<Number> & current_local_solution = *(li_system.current_local_solution);
563  NumericVector<Number> & solution = *(li_system.solution);
564  SparseMatrix<Number> & mmat = *(li_system.matrix);
565  NumericVector<Number> & rhs = *(li_system.rhs);
566 
567  // We need a vector that stores the (diagonal_relaxed-original_diagonal) vector
568  auto diff_diagonal = solution.zero_clone();
569 
570  // Fetch the linear solver from the system
571  PetscLinearSolver<Real> & linear_solver =
572  libMesh::cast_ref<PetscLinearSolver<Real> &>(*li_system.get_linear_solver());
573 
574  _problem.computeLinearSystemSys(li_system, mmat, rhs, true);
575 
576  // Go and relax the system matrix and the right hand side
577  NS::FV::relaxMatrix(mmat, relaxation_factor, *diff_diagonal);
578  NS::FV::relaxRightHandSide(rhs, solution, *diff_diagonal);
579 
580  if (_print_fields)
581  {
582  _console << system.name() << " system matrix" << std::endl;
583  mmat.print();
584  }
585 
586  // We compute the normalization factors based on the fluxes
587  Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
588 
589  // We need the non-preconditioned norm to be consistent with the norm factor
590  LibmeshPetscCall(KSPSetNormType(linear_solver.ksp(), KSP_NORM_UNPRECONDITIONED));
591 
592  // Setting the linear tolerances and maximum iteration counts
593  solver_config.real_valued_data["abs_tol"] = absolute_tol * norm_factor;
594  linear_solver.set_solver_configuration(solver_config);
595 
596  // Solve the system and update current local solution
597  auto its_res_pair = linear_solver.solve(mmat, mmat, solution, rhs);
598  li_system.update();
599 
600  if (_print_fields)
601  {
602  _console << " rhs when we solve " << system.name() << std::endl;
603  rhs.print();
604  _console << system.name() << " solution " << std::endl;
605  solution.print();
606  _console << " Norm factor " << norm_factor << std::endl;
607  }
608 
609  // Limiting scalar solution
610  if (min_value_limiter != std::numeric_limits<Real>::min())
611  NS::FV::limitSolutionUpdate(current_local_solution, min_value_limiter);
612 
613  // Relax the field update for the next momentum predictor
614  if (field_relaxation != 1.0)
615  {
616  auto & old_local_solution = *(system.solutionPreviousNewton());
617  NS::FV::relaxSolutionUpdate(current_local_solution, old_local_solution, field_relaxation);
618 
619  // Update old solution, only needed if relaxing the field
620  old_local_solution = current_local_solution;
621  }
622 
623  system.setSolution(current_local_solution);
624 
625  const auto residuals =
626  std::make_pair(its_res_pair.first, linear_solver.get_initial_residual() / norm_factor);
627 
628  _console << " Advected system: " << system.name() << " " << COLOR_GREEN << residuals.second
629  << COLOR_DEFAULT << " Linear its: " << residuals.first << std::endl;
630 
631  return residuals;
632 }
NS::FV::relaxMatrix
void relaxMatrix(SparseMatrix< Number > &matrix_in, const Real relaxation_parameter, NumericVector< Number > &diff_diagonal)
Relax the matrix to ensure diagonal dominance, we hold onto the difference in diagonals for later use...
Definition: SegregatedSolverUtils.C:25
SolveObject::_problem
FEProblemBase & _problem
SIMPLESolveBase::_print_fields
const bool _print_fields
Debug parameter which allows printing the coupling and solution vectors/matrices. ...
Definition: SIMPLESolveBase.h:267
NS::FV::computeNormalizationFactor
Real computeNormalizationFactor(const NumericVector< Number > &solution, const SparseMatrix< Number > &mat, const NumericVector< Number > &rhs)
Compute a normalization factor which is applied to the linear residual to determine convergence...
Definition: SegregatedSolverUtils.C:135
libMesh::NumericVector::zero_clone
virtual std::unique_ptr< NumericVector< T > > zero_clone() const=0
libMesh::LinearImplicitSystem::rhs
NumericVector< Number > * rhs
LinearSystem::setSolution
void setSolution(const NumericVector< Number > &soln)
libMesh::PetscLinearSolver::solve
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &matrix_in, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
libMesh::LinearImplicitSystem::get_linear_solver
virtual LinearSolver< Number > * get_linear_solver() const override
NS::FV::relaxRightHandSide
void relaxRightHandSide(NumericVector< Number > &rhs_in, const NumericVector< Number > &solution_in, const NumericVector< Number > &diff_diagonal)
Relax the right hand side of an equation, this needs to be called once and the system matrix has been...
Definition: SegregatedSolverUtils.C:91
libMesh::SolverConfiguration::real_valued_data
std::map< std::string, Real > real_valued_data
FEProblemBase::computeLinearSystemSys
virtual void computeLinearSystemSys(libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
LinearSystem::name
virtual const std::string & name() const
libMesh::LinearImplicitSystem::solution
std::unique_ptr< NumericVector< Number > > solution
libMesh::NumericVector::print
virtual void print(std::ostream &os=libMesh::out) const
libMesh::PetscLinearSolver::set_solver_configuration
void set_solver_configuration(SolverConfiguration &solver_configuration)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
libMesh::LinearImplicitSystem::matrix
SparseMatrix< Number > * matrix
FEProblemBase::setCurrentLinearSystem
void setCurrentLinearSystem(unsigned int sys_num)
libMesh::LinearImplicitSystem::current_local_solution
std::unique_ptr< NumericVector< Number > > current_local_solution
LinearSystem::solutionPreviousNewton
virtual const NumericVector< Number > * solutionPreviousNewton() const
SolveObject::_console
const ConsoleStream _console
NS::FV::limitSolutionUpdate
void limitSolutionUpdate(NumericVector< Number > &solution, const Real min_limit=std::numeric_limits< Real >::epsilon(), const Real max_limit=1e10)
Limit a solution to its minimum and maximum bounds: $u = min(max(u, min_limit), max_limit)$.
Definition: SegregatedSolverUtils.C:123
NS::FV::relaxSolutionUpdate
void relaxSolutionUpdate(NumericVector< Number > &vec_new, const NumericVector< Number > &vec_old, const Real relaxation_factor)
Relax the update on a solution field using the following approach: $u = u_{old}+ (u - u_{old})$...
Definition: SegregatedSolverUtils.C:112
libMesh::SparseMatrix::print
void print(std::ostream &os=libMesh::out, const bool sparse=false) const
LinearSystem::system
virtual System & system() override

◆ solveMomentumPredictor()

std::vector< std::pair< unsigned int, Real > > LinearAssemblySegregatedSolve::solveMomentumPredictor ( )
overrideprotectedvirtualinherited

Solve a momentum predictor step with a fixed pressure field.

Returns
A vector of (number of linear iterations, normalized residual norm) pairs for the momentum equations. The length of the vector equals the dimensionality of the domain.

Implements SIMPLESolveBase.

Definition at line 275 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::solve().

276 {
277  // Temporary storage for the (flux-normalized) residuals from
278  // different momentum components
279  std::vector<std::pair<unsigned int, Real>> its_normalized_residuals;
280 
281  LinearImplicitSystem & momentum_system_0 =
282  libMesh::cast_ref<LinearImplicitSystem &>(_momentum_systems[0]->system());
283 
284  PetscLinearSolver<Real> & momentum_solver =
285  libMesh::cast_ref<PetscLinearSolver<Real> &>(*momentum_system_0.get_linear_solver());
286 
287  // Solve the momentum equations.
288  // TO DO: These equations are VERY similar. If we can store the differences (things coming from
289  // BCs for example) separately, it is enough to construct one matrix.
290  for (const auto system_i : index_range(_momentum_systems))
291  {
292  _problem.setCurrentLinearSystem(_momentum_system_numbers[system_i]);
293 
294  // We will need the right hand side and the solution of the next component
295  LinearImplicitSystem & momentum_system =
296  libMesh::cast_ref<LinearImplicitSystem &>(_momentum_systems[system_i]->system());
297 
298  NumericVector<Number> & solution = *(momentum_system.solution);
299  NumericVector<Number> & rhs = *(momentum_system.rhs);
300  SparseMatrix<Number> & mmat = *(momentum_system.matrix);
301 
302  auto diff_diagonal = solution.zero_clone();
303 
304  // We assemble the matrix and the right hand side
305  _problem.computeLinearSystemSys(momentum_system, mmat, rhs, /*compute_grads*/ true);
306 
307  // Still need to relax the right hand side with the same vector
308  NS::FV::relaxMatrix(mmat, _momentum_equation_relaxation, *diff_diagonal);
309  NS::FV::relaxRightHandSide(rhs, solution, *diff_diagonal);
310 
311  // The normalization factor depends on the right hand side so we need to recompute it for this
312  // component
313  Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
314 
315  // Very important, for deciding the convergence, we need the unpreconditioned
316  // norms in the linear solve
317  LibmeshPetscCall(KSPSetNormType(momentum_solver.ksp(), KSP_NORM_UNPRECONDITIONED));
318  // Solve this component. We don't update the ghosted solution yet, that will come at the end
319  // of the corrector step. Also setting the linear tolerances and maximum iteration counts.
320  _momentum_linear_control.real_valued_data["abs_tol"] = _momentum_l_abs_tol * norm_factor;
321  momentum_solver.set_solver_configuration(_momentum_linear_control);
322 
323  // We solve the equation
324  auto its_resid_pair = momentum_solver.solve(mmat, mmat, solution, rhs);
325  momentum_system.update();
326 
327  // We will reuse the preconditioner for every momentum system
328  if (system_i == 0)
329  momentum_solver.reuse_preconditioner(true);
330 
331  // Save the normalized residual
332  its_normalized_residuals.push_back(
333  std::make_pair(its_resid_pair.first, momentum_solver.get_initial_residual() / norm_factor));
334 
335  if (_print_fields)
336  {
337  _console << " matrix when we solve " << std::endl;
338  mmat.print();
339  _console << " rhs when we solve " << std::endl;
340  rhs.print();
341  _console << " velocity solution component " << system_i << std::endl;
342  solution.print();
343  _console << "Norm factor " << norm_factor << std::endl;
344  _console << Moose::stringify(momentum_solver.get_initial_residual()) << std::endl;
345  }
346 
347  // Printing residuals
348  _console << " Momentum equation:"
349  << (_momentum_systems.size() > 1
350  ? std::string(" Component ") + std::to_string(system_i + 1) + std::string(" ")
351  : std::string(" "))
352  << COLOR_GREEN << its_normalized_residuals[system_i].second << COLOR_DEFAULT
353  << " Linear its: " << its_normalized_residuals[system_i].first << std::endl;
354  }
355 
356  for (const auto system_i : index_range(_momentum_systems))
357  {
358  LinearImplicitSystem & momentum_system =
359  libMesh::cast_ref<LinearImplicitSystem &>(_momentum_systems[system_i]->system());
360  _momentum_systems[system_i]->setSolution(*(momentum_system.current_local_solution));
361  _momentum_systems[system_i]->copyPreviousNonlinearSolutions();
362  }
363 
364  // We reset this to ensure the preconditioner is recomputed new time we go to the momentum
365  // predictor
366  momentum_solver.reuse_preconditioner(false);
367 
368  return its_normalized_residuals;
369 }
NS::FV::relaxMatrix
void relaxMatrix(SparseMatrix< Number > &matrix_in, const Real relaxation_parameter, NumericVector< Number > &diff_diagonal)
Relax the matrix to ensure diagonal dominance, we hold onto the difference in diagonals for later use...
Definition: SegregatedSolverUtils.C:25
SolveObject::_problem
FEProblemBase & _problem
SIMPLESolveBase::_momentum_linear_control
SIMPLESolverConfiguration _momentum_linear_control
Options for the linear solver of the momentum equation.
Definition: SIMPLESolveBase.h:85
SIMPLESolveBase::_print_fields
const bool _print_fields
Debug parameter which allows printing the coupling and solution vectors/matrices. ...
Definition: SIMPLESolveBase.h:267
NS::FV::computeNormalizationFactor
Real computeNormalizationFactor(const NumericVector< Number > &solution, const SparseMatrix< Number > &mat, const NumericVector< Number > &rhs)
Compute a normalization factor which is applied to the linear residual to determine convergence...
Definition: SegregatedSolverUtils.C:135
SIMPLESolveBase::_momentum_equation_relaxation
const Real _momentum_equation_relaxation
The user-defined relaxation parameter for the momentum equation.
Definition: SIMPLESolveBase.h:95
libMesh::LinearImplicitSystem::rhs
NumericVector< Number > * rhs
SIMPLESolveBase::_momentum_l_abs_tol
const Real _momentum_l_abs_tol
Absolute linear tolerance for the momentum equation(s).
Definition: SIMPLESolveBase.h:89
libMesh::LinearImplicitSystem::get_linear_solver
virtual LinearSolver< Number > * get_linear_solver() const override
NS::FV::relaxRightHandSide
void relaxRightHandSide(NumericVector< Number > &rhs_in, const NumericVector< Number > &solution_in, const NumericVector< Number > &diff_diagonal)
Relax the right hand side of an equation, this needs to be called once and the system matrix has been...
Definition: SegregatedSolverUtils.C:91
libMesh::SolverConfiguration::real_valued_data
std::map< std::string, Real > real_valued_data
FEProblemBase::computeLinearSystemSys
virtual void computeLinearSystemSys(libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
LinearAssemblySegregatedSolve::_momentum_system_numbers
std::vector< unsigned int > _momentum_system_numbers
The number(s) of the system(s) corresponding to the momentum equation(s)
Definition: LinearAssemblySegregatedSolve.h:110
libMesh::SparseMatrix::zero_clone
virtual std::unique_ptr< SparseMatrix< T > > zero_clone() const=0
libMesh::LinearImplicitSystem::solution
std::unique_ptr< NumericVector< Number > > solution
libMesh::NumericVector::print
virtual void print(std::ostream &os=libMesh::out) const
Moose::stringify
std::string stringify(const T &t)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
libMesh::LinearImplicitSystem::matrix
SparseMatrix< Number > * matrix
FEProblemBase::setCurrentLinearSystem
void setCurrentLinearSystem(unsigned int sys_num)
libMesh::LinearImplicitSystem::current_local_solution
std::unique_ptr< NumericVector< Number > > current_local_solution
SolveObject::_console
const ConsoleStream _console
LinearAssemblySegregatedSolve::_momentum_systems
std::vector< LinearSystem * > _momentum_systems
Pointer(s) to the system(s) corresponding to the momentum equation(s)
Definition: LinearAssemblySegregatedSolve.h:113
index_range
auto index_range(const T &sizable)
libMesh::SparseMatrix::print
void print(std::ostream &os=libMesh::out, const bool sparse=false) const

◆ solvePressureCorrector()

std::pair< unsigned int, Real > LinearAssemblySegregatedSolve::solvePressureCorrector ( )
overrideprotectedvirtualinherited

Solve a pressure corrector step.

Returns
The number of linear iterations and the normalized residual norm of the pressure equation.

Implements SIMPLESolveBase.

Definition at line 382 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::correctVelocity().

383 {
384  _problem.setCurrentLinearSystem(_pressure_sys_number);
385 
386  // We will need some members from the linear system
387  LinearImplicitSystem & pressure_system =
388  libMesh::cast_ref<LinearImplicitSystem &>(_pressure_system.system());
389 
390  // We will need the solution, the right hand side and the matrix
391  NumericVector<Number> & current_local_solution = *(pressure_system.current_local_solution);
392  NumericVector<Number> & solution = *(pressure_system.solution);
393  SparseMatrix<Number> & mmat = *(pressure_system.matrix);
394  NumericVector<Number> & rhs = *(pressure_system.rhs);
395 
396  // Fetch the linear solver from the system
397  PetscLinearSolver<Real> & pressure_solver =
398  libMesh::cast_ref<PetscLinearSolver<Real> &>(*pressure_system.get_linear_solver());
399 
400  _problem.computeLinearSystemSys(pressure_system, mmat, rhs, false);
401 
402  if (_print_fields)
403  {
404  _console << "Pressure matrix" << std::endl;
405  mmat.print();
406  }
407 
408  // We compute the normalization factors based on the fluxes
409  Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
410 
411  // We need the non-preconditioned norm to be consistent with the norm factor
412  LibmeshPetscCall(KSPSetNormType(pressure_solver.ksp(), KSP_NORM_UNPRECONDITIONED));
413 
414  // Setting the linear tolerances and maximum iteration counts
415  _pressure_linear_control.real_valued_data["abs_tol"] = _pressure_l_abs_tol * norm_factor;
416  pressure_solver.set_solver_configuration(_pressure_linear_control);
417 
418  if (_pin_pressure)
419  NS::FV::constrainSystem(mmat, rhs, _pressure_pin_value, _pressure_pin_dof);
420  pressure_system.update();
421 
422  auto its_res_pair = pressure_solver.solve(mmat, mmat, solution, rhs);
423  pressure_system.update();
424 
425  if (_print_fields)
426  {
427  _console << " rhs when we solve pressure " << std::endl;
428  rhs.print();
429  _console << " Pressure " << std::endl;
430  solution.print();
431  _console << "Norm factor " << norm_factor << std::endl;
432  }
433 
434  _pressure_system.setSolution(current_local_solution);
435 
436  const auto residuals =
437  std::make_pair(its_res_pair.first, pressure_solver.get_initial_residual() / norm_factor);
438 
439  _console << " Pressure equation: " << COLOR_GREEN << residuals.second << COLOR_DEFAULT
440  << " Linear its: " << residuals.first << std::endl;
441 
442  return residuals;
443 }
SolveObject::_problem
FEProblemBase & _problem
SIMPLESolveBase::_print_fields
const bool _print_fields
Debug parameter which allows printing the coupling and solution vectors/matrices. ...
Definition: SIMPLESolveBase.h:267
NS::FV::computeNormalizationFactor
Real computeNormalizationFactor(const NumericVector< Number > &solution, const SparseMatrix< Number > &mat, const NumericVector< Number > &rhs)
Compute a normalization factor which is applied to the linear residual to determine convergence...
Definition: SegregatedSolverUtils.C:135
libMesh::LinearImplicitSystem::rhs
NumericVector< Number > * rhs
LinearSystem::setSolution
void setSolution(const NumericVector< Number > &soln)
libMesh::PetscLinearSolver::solve
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &matrix_in, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
libMesh::LinearImplicitSystem::get_linear_solver
virtual LinearSolver< Number > * get_linear_solver() const override
libMesh::SolverConfiguration::real_valued_data
std::map< std::string, Real > real_valued_data
FEProblemBase::computeLinearSystemSys
virtual void computeLinearSystemSys(libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
LinearAssemblySegregatedSolve::_pressure_system
LinearSystem & _pressure_system
Reference to the linear system corresponding to the pressure equation.
Definition: LinearAssemblySegregatedSolve.h:119
SIMPLESolveBase::_pressure_linear_control
SIMPLESolverConfiguration _pressure_linear_control
Options for the linear solver of the pressure equation.
Definition: SIMPLESolveBase.h:103
SIMPLESolveBase::_pressure_l_abs_tol
const Real _pressure_l_abs_tol
Absolute linear tolerance for the pressure equation.
Definition: SIMPLESolveBase.h:107
libMesh::LinearImplicitSystem::solution
std::unique_ptr< NumericVector< Number > > solution
SIMPLESolveBase::_pressure_pin_dof
dof_id_type _pressure_pin_dof
The dof ID where the pressure needs to be pinned.
Definition: SIMPLESolveBase.h:122
libMesh::NumericVector::print
virtual void print(std::ostream &os=libMesh::out) const
SIMPLESolveBase::_pin_pressure
const bool _pin_pressure
If the pressure needs to be pinned.
Definition: SIMPLESolveBase.h:116
libMesh::PetscLinearSolver::set_solver_configuration
void set_solver_configuration(SolverConfiguration &solver_configuration)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
libMesh::LinearImplicitSystem::matrix
SparseMatrix< Number > * matrix
FEProblemBase::setCurrentLinearSystem
void setCurrentLinearSystem(unsigned int sys_num)
SIMPLESolveBase::_pressure_pin_value
const Real _pressure_pin_value
The value we want to enforce for pressure.
Definition: SIMPLESolveBase.h:119
libMesh::LinearImplicitSystem::current_local_solution
std::unique_ptr< NumericVector< Number > > current_local_solution
SolveObject::_console
const ConsoleStream _console
NS::FV::constrainSystem
void constrainSystem(SparseMatrix< Number > &mx, NumericVector< Number > &rhs, const Real desired_value, const dof_id_type dof_id)
Implicitly constrain the system by adding a factor*(u-u_desired) to it at a desired dof value...
Definition: SegregatedSolverUtils.C:180
libMesh::SparseMatrix::print
void print(std::ostream &os=libMesh::out, const bool sparse=false) const
LinearSystem::system
virtual System & system() override
LinearAssemblySegregatedSolve::_pressure_sys_number
const unsigned int _pressure_sys_number
The number of the system corresponding to the pressure equation.
Definition: LinearAssemblySegregatedSolve.h:116

◆ solveSolidEnergy()

std::pair< unsigned int, Real > LinearAssemblySegregatedSolve::solveSolidEnergy ( )
protectedinherited

Solve an equation which contains the solid energy conservation.

Definition at line 446 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::solve().

447 {
448  _problem.setCurrentLinearSystem(_solid_energy_sys_number);
449 
450  // We will need some members from the linear system
451  LinearImplicitSystem & system =
452  libMesh::cast_ref<LinearImplicitSystem &>(_solid_energy_system->system());
453 
454  // We will need the solution, the right hand side and the matrix
455  NumericVector<Number> & current_local_solution = *(system.current_local_solution);
456  NumericVector<Number> & solution = *(system.solution);
457  SparseMatrix<Number> & mmat = *(system.matrix);
458  NumericVector<Number> & rhs = *(system.rhs);
459 
460  // Fetch the linear solver from the system
461  PetscLinearSolver<Real> & solver =
462  libMesh::cast_ref<PetscLinearSolver<Real> &>(*system.get_linear_solver());
463 
464  _problem.computeLinearSystemSys(system, mmat, rhs, false);
465 
466  if (_print_fields)
467  {
468  _console << "Solid energy matrix" << std::endl;
469  mmat.print();
470  }
471 
472  // We compute the normalization factors based on the fluxes
473  Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
474 
475  // We need the non-preconditioned norm to be consistent with the norm factor
476  LibmeshPetscCall(KSPSetNormType(solver.ksp(), KSP_NORM_UNPRECONDITIONED));
477 
478  // Setting the linear tolerances and maximum iteration counts
479  _solid_energy_linear_control.real_valued_data["abs_tol"] = _solid_energy_l_abs_tol * norm_factor;
480  solver.set_solver_configuration(_solid_energy_linear_control);
481 
482  auto its_res_pair = solver.solve(mmat, mmat, solution, rhs);
483  system.update();
484 
485  if (_print_fields)
486  {
487  _console << " rhs when we solve solid energy " << std::endl;
488  rhs.print();
489  _console << " Solid energy " << std::endl;
490  solution.print();
491  _console << "Norm factor " << norm_factor << std::endl;
492  }
493 
494  _solid_energy_system->setSolution(current_local_solution);
495 
496  const auto residuals =
497  std::make_pair(its_res_pair.first, solver.get_initial_residual() / norm_factor);
498 
499  _console << " Solid energy equation: " << COLOR_GREEN << residuals.second << COLOR_DEFAULT
500  << " Linear its: " << residuals.first << std::endl;
501 
502  return residuals;
503 }
SolveObject::_problem
FEProblemBase & _problem
SIMPLESolveBase::_print_fields
const bool _print_fields
Debug parameter which allows printing the coupling and solution vectors/matrices. ...
Definition: SIMPLESolveBase.h:267
SIMPLESolveBase::_solid_energy_l_abs_tol
const Real _solid_energy_l_abs_tol
Absolute linear tolerance for the energy equations.
Definition: SIMPLESolveBase.h:155
NS::FV::computeNormalizationFactor
Real computeNormalizationFactor(const NumericVector< Number > &solution, const SparseMatrix< Number > &mat, const NumericVector< Number > &rhs)
Compute a normalization factor which is applied to the linear residual to determine convergence...
Definition: SegregatedSolverUtils.C:135
LinearAssemblySegregatedSolve::_solid_energy_system
LinearSystem * _solid_energy_system
Pointer to the linear system corresponding to the solid energy equation.
Definition: LinearAssemblySegregatedSolve.h:131
libMesh::LinearImplicitSystem::rhs
NumericVector< Number > * rhs
LinearSystem::setSolution
void setSolution(const NumericVector< Number > &soln)
libMesh::PetscLinearSolver::solve
virtual std::pair< unsigned int, Real > solve(SparseMatrix< T > &matrix_in, NumericVector< T > &solution_in, NumericVector< T > &rhs_in, const std::optional< double > tol=std::nullopt, const std::optional< unsigned int > m_its=std::nullopt) override
libMesh::LinearImplicitSystem::get_linear_solver
virtual LinearSolver< Number > * get_linear_solver() const override
libMesh::SolverConfiguration::real_valued_data
std::map< std::string, Real > real_valued_data
FEProblemBase::computeLinearSystemSys
virtual void computeLinearSystemSys(libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
LinearAssemblySegregatedSolve::_solid_energy_sys_number
const unsigned int _solid_energy_sys_number
The number of the system corresponding to the solid energy equation.
Definition: LinearAssemblySegregatedSolve.h:128
libMesh::LinearImplicitSystem::solution
std::unique_ptr< NumericVector< Number > > solution
libMesh::NumericVector::print
virtual void print(std::ostream &os=libMesh::out) const
libMesh::PetscLinearSolver::set_solver_configuration
void set_solver_configuration(SolverConfiguration &solver_configuration)
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
libMesh::LinearImplicitSystem::matrix
SparseMatrix< Number > * matrix
FEProblemBase::setCurrentLinearSystem
void setCurrentLinearSystem(unsigned int sys_num)
libMesh::LinearImplicitSystem::current_local_solution
std::unique_ptr< NumericVector< Number > > current_local_solution
SolveObject::_console
const ConsoleStream _console
SIMPLESolveBase::_solid_energy_linear_control
SIMPLESolverConfiguration _solid_energy_linear_control
Options for the linear solver of the energy equation.
Definition: SIMPLESolveBase.h:151
libMesh::SparseMatrix::print
void print(std::ostream &os=libMesh::out, const bool sparse=false) const
LinearSystem::system
virtual System & system() override

◆ systemsToSolve()

const std::vector<LinearSystem *> LinearAssemblySegregatedSolve::systemsToSolve ( ) const
inlineinherited

Return pointers to the systems which are solved for within this object.

Definition at line 41 of file LinearAssemblySegregatedSolve.h.

Referenced by PIMPLE::getTimeIntegrators(), and PIMPLE::relativeSolutionDifferenceNorm().

41 { return _systems_to_solve; }
LinearAssemblySegregatedSolve::_systems_to_solve
std::vector< LinearSystem * > _systems_to_solve
Shortcut to every linear system that we solve for here.
Definition: LinearAssemblySegregatedSolve.h:149

◆ validParams()

InputParameters SIMPLESolve::validParams ( )
static

Definition at line 18 of file SIMPLESolve.C.

Referenced by SIMPLE::validParams().

19 {
20  InputParameters params = LinearAssemblySegregatedSolve::validParams();
21  return params;
22 }

Member Data Documentation

◆ _active_scalar_absolute_tolerance

const std::vector<Real> LinearAssemblySegregatedSolve::_active_scalar_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence in active scalars.

Definition at line 186 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage().

◆ _active_scalar_equation_relaxation

const std::vector<Real> LinearAssemblySegregatedSolve::_active_scalar_equation_relaxation
protectedinherited

The user-defined relaxation parameter(s) for the active scalar equation(s)

Definition at line 173 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _active_scalar_l_abs_tol

const Real LinearAssemblySegregatedSolve::_active_scalar_l_abs_tol
protectedinherited

Absolute linear tolerance for the active scalar equation(s).

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 183 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _active_scalar_linear_control

SIMPLESolverConfiguration LinearAssemblySegregatedSolve::_active_scalar_linear_control
protectedinherited

Options for the linear solver of the active scalar equation(s)

Definition at line 179 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _active_scalar_petsc_options

Moose::PetscSupport::PetscOptions LinearAssemblySegregatedSolve::_active_scalar_petsc_options
protectedinherited

Options which hold the petsc settings for the active scalar equation(s)

Definition at line 176 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _active_scalar_system_names

const std::vector<SolverSystemName>& LinearAssemblySegregatedSolve::_active_scalar_system_names
protectedinherited

The names of the active scalar systems.

Definition at line 164 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _active_scalar_system_numbers

std::vector<unsigned int> LinearAssemblySegregatedSolve::_active_scalar_system_numbers
protectedinherited

Definition at line 170 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _active_scalar_systems

std::vector<LinearSystem *> LinearAssemblySegregatedSolve::_active_scalar_systems
protectedinherited

Pointer(s) to the system(s) corresponding to the active scalar equation(s)

Definition at line 140 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _cht

NS::FV::CHTHandler LinearAssemblySegregatedSolve::_cht
protectedinherited

********************** Conjugate heat transfer variables ************** //

Definition at line 191 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::initialSetup(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _continue_on_max_its

const bool SIMPLESolveBase::_continue_on_max_its
protectedinherited

If solve should continue if maximum number of iterations is hit.

Definition at line 262 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _energy_absolute_tolerance

const Real SIMPLESolveBase::_energy_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence in energy.

Definition at line 244 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage(), and SIMPLESolveNonlinearAssembly::solve().

◆ _energy_equation_relaxation

const Real SIMPLESolveBase::_energy_equation_relaxation
protectedinherited

The user-defined relaxation parameter for the energy equation.

Definition at line 130 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _energy_l_abs_tol

const Real SIMPLESolveBase::_energy_l_abs_tol
protectedinherited

Absolute linear tolerance for the energy equations.

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 140 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _energy_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_energy_linear_control
protectedinherited

Options for the linear solver of the energy equation.

Definition at line 136 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_energy_petsc_options
protectedinherited

Options which hold the petsc settings for the fluid energy equation.

Definition at line 133 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _energy_sys_number

const unsigned int LinearAssemblySegregatedSolve::_energy_sys_number
protectedinherited

The number of the system corresponding to the energy equation.

Definition at line 122 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _energy_system

LinearSystem* LinearAssemblySegregatedSolve::_energy_system
protectedinherited

Pointer to the linear system corresponding to the fluid energy equation.

Definition at line 125 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _has_active_scalar_systems

const bool LinearAssemblySegregatedSolve::_has_active_scalar_systems
protectedinherited

Boolean for easy check if a active scalar systems shall be solved or not.

Definition at line 167 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _has_energy_system

const bool SIMPLESolveBase::_has_energy_system
protectedinherited

Boolean for easy check if a fluid energy system shall be solved or not.

Definition at line 127 of file SIMPLESolveBase.h.

Referenced by checkIntegrity(), SIMPLESolveNonlinearAssembly::checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _has_passive_scalar_systems

const bool SIMPLESolveBase::_has_passive_scalar_systems
protectedinherited

Boolean for easy check if a passive scalar systems shall be solved or not.

Definition at line 163 of file SIMPLESolveBase.h.

Referenced by checkIntegrity(), SIMPLESolveNonlinearAssembly::checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _has_pm_radiation_systems

const bool SIMPLESolveBase::_has_pm_radiation_systems
protectedinherited

Boolean for easy check if participating media radiation systems shall be solved or not.

Definition at line 187 of file SIMPLESolveBase.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _has_solid_energy_system

const bool SIMPLESolveBase::_has_solid_energy_system
protectedinherited

Boolean for easy check if a solid energy system shall be solved or not.

Definition at line 145 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _has_turbulence_systems

const bool SIMPLESolveBase::_has_turbulence_systems
protectedinherited

Boolean for easy check if a turbulence scalar systems shall be solved or not.

Definition at line 211 of file SIMPLESolveBase.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _momentum_absolute_tolerance

const Real SIMPLESolveBase::_momentum_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence in momentum.

Definition at line 238 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage(), and SIMPLESolveNonlinearAssembly::solve().

◆ _momentum_equation_relaxation

const Real SIMPLESolveBase::_momentum_equation_relaxation
protectedinherited

The user-defined relaxation parameter for the momentum equation.

Definition at line 95 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solveMomentumPredictor(), and LinearAssemblySegregatedSolve::solveMomentumPredictor().

◆ _momentum_l_abs_tol

const Real SIMPLESolveBase::_momentum_l_abs_tol
protectedinherited

Absolute linear tolerance for the momentum equation(s).

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 89 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solveMomentumPredictor(), and LinearAssemblySegregatedSolve::solveMomentumPredictor().

◆ _momentum_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_momentum_linear_control
protectedinherited

Options for the linear solver of the momentum equation.

Definition at line 85 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solveMomentumPredictor(), and LinearAssemblySegregatedSolve::solveMomentumPredictor().

◆ _momentum_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_momentum_petsc_options
protectedinherited

Options which hold the petsc settings for the momentum equation.

Definition at line 92 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _momentum_system_names

const std::vector<SolverSystemName>& SIMPLESolveBase::_momentum_system_names
protectedinherited

The names of the momentum systems.

Definition at line 82 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), SIMPLESolveBase::SIMPLESolveBase(), and SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly().

◆ _momentum_system_numbers

std::vector<unsigned int> LinearAssemblySegregatedSolve::_momentum_system_numbers
protectedinherited

The number(s) of the system(s) corresponding to the momentum equation(s)

Definition at line 110 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::linkRhieChowUserObject(), and LinearAssemblySegregatedSolve::solveMomentumPredictor().

◆ _momentum_systems

std::vector<LinearSystem *> LinearAssemblySegregatedSolve::_momentum_systems
protectedinherited

Pointer(s) to the system(s) corresponding to the momentum equation(s)

Definition at line 113 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::linkRhieChowUserObject(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solveMomentumPredictor().

◆ _num_iterations

const unsigned int SIMPLESolveBase::_num_iterations
protectedinherited

The maximum number of momentum-pressure iterations.

Definition at line 259 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_absolute_tolerance

const std::vector<Real> SIMPLESolveBase::_passive_scalar_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence in passive scalars.

Definition at line 250 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_equation_relaxation

const std::vector<Real> SIMPLESolveBase::_passive_scalar_equation_relaxation
protectedinherited

The user-defined relaxation parameter(s) for the passive scalar equation(s)

Definition at line 169 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_l_abs_tol

const Real SIMPLESolveBase::_passive_scalar_l_abs_tol
protectedinherited

Absolute linear tolerance for the passive scalar equation(s).

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 179 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_passive_scalar_linear_control
protectedinherited

Options for the linear solver of the passive scalar equation(s)

Definition at line 175 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_passive_scalar_petsc_options
protectedinherited

Options which hold the petsc settings for the passive scalar equation(s)

Definition at line 172 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_system_names

const std::vector<SolverSystemName>& SIMPLESolveBase::_passive_scalar_system_names
protectedinherited

The names of the passive scalar systems.

Definition at line 160 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_system_numbers

std::vector<unsigned int> SIMPLESolveBase::_passive_scalar_system_numbers
protectedinherited

Definition at line 166 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _passive_scalar_systems

std::vector<LinearSystem *> LinearAssemblySegregatedSolve::_passive_scalar_systems
protectedinherited

Pointer(s) to the system(s) corresponding to the passive scalar equation(s)

Definition at line 134 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _pin_pressure

const bool SIMPLESolveBase::_pin_pressure
protectedinherited

If the pressure needs to be pinned.

Definition at line 116 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::setupPressurePin(), SIMPLESolveNonlinearAssembly::solvePressureCorrector(), and LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pm_radiation_absolute_tolerance

const std::vector<Real> SIMPLESolveBase::_pm_radiation_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence in participating media radiation.

Definition at line 253 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage(), and SIMPLESolveBase::SIMPLESolveBase().

◆ _pm_radiation_equation_relaxation

const std::vector<Real> SIMPLESolveBase::_pm_radiation_equation_relaxation
protectedinherited

The user-defined relaxation parameter(s) for the participating media radiation equation(s)

Definition at line 193 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _pm_radiation_l_abs_tol

const Real SIMPLESolveBase::_pm_radiation_l_abs_tol
protectedinherited

Absolute linear tolerance for the participating media radiation equation(s).

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 203 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _pm_radiation_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_pm_radiation_linear_control
protectedinherited

Options for the linear solver of the participating media radiation equation(s)

Definition at line 199 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _pm_radiation_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_pm_radiation_petsc_options
protectedinherited

Options which hold the petsc settings for the participating media radiation equation(s)

Definition at line 196 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _pm_radiation_system_names

const std::vector<SolverSystemName>& SIMPLESolveBase::_pm_radiation_system_names
protectedinherited

The names of the participating media radiation systems.

Definition at line 184 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _pm_radiation_system_numbers

std::vector<unsigned int> SIMPLESolveBase::_pm_radiation_system_numbers
protectedinherited

Definition at line 190 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _pm_radiation_systems

std::vector<LinearSystem *> LinearAssemblySegregatedSolve::_pm_radiation_systems
protectedinherited

Pointer(s) to the system(s) corresponding to the participting media radiation equation(s)

Definition at line 137 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _pressure_absolute_tolerance

const Real SIMPLESolveBase::_pressure_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence in pressure.

Definition at line 241 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage(), and SIMPLESolveNonlinearAssembly::solve().

◆ _pressure_l_abs_tol

const Real SIMPLESolveBase::_pressure_l_abs_tol
protectedinherited

Absolute linear tolerance for the pressure equation.

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 107 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solvePressureCorrector(), and LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pressure_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_pressure_linear_control
protectedinherited

Options for the linear solver of the pressure equation.

Definition at line 103 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solvePressureCorrector(), and LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pressure_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_pressure_petsc_options
protectedinherited

Options which hold the petsc settings for the pressure equation.

Definition at line 110 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::correctVelocity(), SIMPLESolveBase::SIMPLESolveBase(), and SIMPLESolveNonlinearAssembly::solve().

◆ _pressure_pin_dof

dof_id_type SIMPLESolveBase::_pressure_pin_dof
protectedinherited

The dof ID where the pressure needs to be pinned.

Definition at line 122 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::setupPressurePin(), SIMPLESolveNonlinearAssembly::solvePressureCorrector(), and LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pressure_pin_value

const Real SIMPLESolveBase::_pressure_pin_value
protectedinherited

The value we want to enforce for pressure.

Definition at line 119 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveNonlinearAssembly::solvePressureCorrector(), and LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pressure_sys_number

const unsigned int LinearAssemblySegregatedSolve::_pressure_sys_number
protectedinherited

The number of the system corresponding to the pressure equation.

Definition at line 116 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pressure_system

LinearSystem& LinearAssemblySegregatedSolve::_pressure_system
protectedinherited

Reference to the linear system corresponding to the pressure equation.

Definition at line 119 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::correctVelocity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::linkRhieChowUserObject(), LinearAssemblySegregatedSolve::solve(), and LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pressure_system_name

const SolverSystemName& SIMPLESolveBase::_pressure_system_name
protectedinherited

The name of the pressure system.

Definition at line 100 of file SIMPLESolveBase.h.

◆ _pressure_variable_relaxation

const Real SIMPLESolveBase::_pressure_variable_relaxation
protectedinherited

The user-defined relaxation parameter for the pressure variable.

Definition at line 113 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::correctVelocity(), and SIMPLESolveNonlinearAssembly::solve().

◆ _print_fields

const bool SIMPLESolveBase::_print_fields
protectedinherited

Debug parameter which allows printing the coupling and solution vectors/matrices.

Definition at line 267 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::correctVelocity(), SIMPLESolveNonlinearAssembly::solve(), SIMPLESolveNonlinearAssembly::solveAdvectedSystem(), LinearAssemblySegregatedSolve::solveAdvectedSystem(), SIMPLESolveNonlinearAssembly::solveMomentumPredictor(), LinearAssemblySegregatedSolve::solveMomentumPredictor(), SIMPLESolveNonlinearAssembly::solvePressureCorrector(), LinearAssemblySegregatedSolve::solvePressureCorrector(), LinearAssemblySegregatedSolve::solveSolidEnergy(), and SIMPLESolveNonlinearAssembly::solveSolidEnergySystem().

◆ _rc_uo

RhieChowMassFlux* LinearAssemblySegregatedSolve::_rc_uo
protectedinherited

Pointer to the segregated RhieChow interpolation object.

Definition at line 146 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::correctVelocity(), and LinearAssemblySegregatedSolve::linkRhieChowUserObject().

◆ _should_solve_active_scalars

const bool LinearAssemblySegregatedSolve::_should_solve_active_scalars
protectedinherited

Definition at line 158 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _should_solve_energy

const bool LinearAssemblySegregatedSolve::_should_solve_energy
protectedinherited

Definition at line 154 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _should_solve_momentum

const bool LinearAssemblySegregatedSolve::_should_solve_momentum
protectedinherited

Flags controlling which systems are actively solved (can be used with restart to freeze flow)

Definition at line 152 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::linkRhieChowUserObject(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _should_solve_passive_scalars

const bool LinearAssemblySegregatedSolve::_should_solve_passive_scalars
protectedinherited

Definition at line 157 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _should_solve_pm_radiation

const bool LinearAssemblySegregatedSolve::_should_solve_pm_radiation
protectedinherited

Definition at line 159 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _should_solve_pressure

const bool LinearAssemblySegregatedSolve::_should_solve_pressure
protectedinherited

Definition at line 153 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _should_solve_solid_energy

const bool LinearAssemblySegregatedSolve::_should_solve_solid_energy
protectedinherited

Definition at line 155 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _should_solve_turbulence

const bool LinearAssemblySegregatedSolve::_should_solve_turbulence
protectedinherited

Definition at line 156 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), and LinearAssemblySegregatedSolve::solve().

◆ _solid_energy_absolute_tolerance

const Real SIMPLESolveBase::_solid_energy_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence in solid energy.

Definition at line 247 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage(), and SIMPLESolveNonlinearAssembly::solve().

◆ _solid_energy_l_abs_tol

const Real SIMPLESolveBase::_solid_energy_l_abs_tol
protectedinherited

Absolute linear tolerance for the energy equations.

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 155 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::solveSolidEnergy(), and SIMPLESolveNonlinearAssembly::solveSolidEnergySystem().

◆ _solid_energy_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_solid_energy_linear_control
protectedinherited

Options for the linear solver of the energy equation.

Definition at line 151 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), LinearAssemblySegregatedSolve::solveSolidEnergy(), and SIMPLESolveNonlinearAssembly::solveSolidEnergySystem().

◆ _solid_energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_solid_energy_petsc_options
protectedinherited

Options which hold the petsc settings for the fluid energy equation.

Definition at line 148 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _solid_energy_sys_number

const unsigned int LinearAssemblySegregatedSolve::_solid_energy_sys_number
protectedinherited

The number of the system corresponding to the solid energy equation.

Definition at line 128 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solveSolidEnergy().

◆ _solid_energy_system

LinearSystem* LinearAssemblySegregatedSolve::_solid_energy_system
protectedinherited

Pointer to the linear system corresponding to the solid energy equation.

Definition at line 131 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::solve(), and LinearAssemblySegregatedSolve::solveSolidEnergy().

◆ _systems_to_solve

std::vector<LinearSystem *> LinearAssemblySegregatedSolve::_systems_to_solve
protectedinherited

Shortcut to every linear system that we solve for here.

Definition at line 149 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::systemsToSolve().

◆ _turbulence_absolute_tolerance

const std::vector<Real> SIMPLESolveBase::_turbulence_absolute_tolerance
protectedinherited

The user-defined absolute tolerance for determining the convergence turbulence variables.

Definition at line 256 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage(), and SIMPLESolveBase::SIMPLESolveBase().

◆ _turbulence_equation_relaxation

const std::vector<Real> SIMPLESolveBase::_turbulence_equation_relaxation
protectedinherited

The user-defined relaxation parameter(s) for the turbulence equation(s)

Definition at line 217 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _turbulence_field_min_limit

std::vector<Real> SIMPLESolveBase::_turbulence_field_min_limit
protectedinherited

The user-defined lower limit for turbulent quantities e.g. k, eps/omega, etc..

Definition at line 223 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _turbulence_field_relaxation

std::vector<Real> SIMPLESolveBase::_turbulence_field_relaxation
protectedinherited

The user-defined relaxation parameter(s) for the turbulence field(s)

Definition at line 220 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _turbulence_l_abs_tol

const Real SIMPLESolveBase::_turbulence_l_abs_tol
protectedinherited

Absolute linear tolerance for the turbulence equation(s).

We need to store this, because it needs to be scaled with a representative flux.

Definition at line 233 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _turbulence_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_turbulence_linear_control
protectedinherited

Options for the linear solver of the turbulence equation(s)

Definition at line 229 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _turbulence_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_turbulence_petsc_options
protectedinherited

Options which hold the petsc settings for the turbulence equation(s)

Definition at line 226 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _turbulence_system_names

const std::vector<SolverSystemName>& SIMPLESolveBase::_turbulence_system_names
protectedinherited

The names of the turbulence systems.

Definition at line 208 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), LinearAssemblySegregatedSolve::setupResidualStorage(), SIMPLESolveBase::SIMPLESolveBase(), and LinearAssemblySegregatedSolve::solve().

◆ _turbulence_system_numbers

std::vector<unsigned int> SIMPLESolveBase::_turbulence_system_numbers
protectedinherited

Definition at line 214 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

◆ _turbulence_systems

std::vector<LinearSystem *> LinearAssemblySegregatedSolve::_turbulence_systems
protectedinherited

Pointer(s) to the system(s) corresponding to the turbulence equation(s)

Definition at line 143 of file LinearAssemblySegregatedSolve.h.

Referenced by checkIntegrity(), LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve(), and LinearAssemblySegregatedSolve::solve().

The documentation for this class was generated from the following files:
Generated on Wed Jun 24 2026 08:35:51 for https://mooseframework.inl.gov by   doxygen 1.8.14