Solve class serving as a base class for the two SIMPLE solvers that operate with different assembly algorithms. More...

#include <SIMPLESolveBase.h>

Inheritance diagram for SIMPLESolveBase:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SIMPLESolveBase (Executioner &ex)

virtual void	setInnerSolve (SolveObject &) override

virtual void	linkRhieChowUserObject ()=0
	Fetch the Rhie Chow user object that is reponsible for determining face velocities and mass flux. More...

void	setupPressurePin ()
	Setup pressure pin if there is need for one. More...

virtual void	checkIntegrity ()
	Check if the user defined time kernels. More...

virtual void	initialSetup ()

virtual bool	solve ()=0

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () 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	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	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	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) 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 UserObject &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObject &	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)

Public Attributes
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

Protected Member Functions
void	checkDependentParameterError (const std::string &main_parameter, const std::vector< std::string > &dependent_parameters, const bool should_be_defined)

virtual std::vector< std::pair< unsigned int, Real > >	solveMomentumPredictor ()=0
	Solve a momentum predictor step with a fixed pressure field. More...

virtual std::pair< unsigned int, Real >	solvePressureCorrector ()=0
	Solve a pressure corrector step. More...

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 UserObject &) const

Protected Attributes
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 > &	_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 >	_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

Solve class serving as a base class for the two SIMPLE solvers that operate with different assembly algorithms.

Includes base routines and variables for the coupling of momentum and pressure.

Definition at line 41 of file SIMPLESolveBase.h.

Constructor & Destructor Documentation

◆ SIMPLESolveBase()

SIMPLESolveBase::SIMPLESolveBase ( Executioner & ex )

Definition at line 365 of file SIMPLESolveBase.C.

   : SolveObject(ex),
     UserObjectInterface(this),
     _momentum_system_names(getParam<std::vector<SolverSystemName>>("momentum_systems")),
     _momentum_l_abs_tol(getParam<Real>("momentum_l_abs_tol")),
     _momentum_equation_relaxation(getParam<Real>("momentum_equation_relaxation")),
     _pressure_system_name(getParam<SolverSystemName>("pressure_system")),
     _pressure_l_abs_tol(getParam<Real>("pressure_l_abs_tol")),
     _pressure_variable_relaxation(getParam<Real>("pressure_variable_relaxation")),
     _pin_pressure(getParam<bool>("pin_pressure")),
     _pressure_pin_value(getParam<Real>("pressure_pin_value")),
     _pressure_pin_dof(libMesh::invalid_uint),
     _has_energy_system(isParamValid("energy_system")),
     _energy_equation_relaxation(getParam<Real>("energy_equation_relaxation")),
     _energy_l_abs_tol(getParam<Real>("energy_l_abs_tol")),
     _has_solid_energy_system(_has_energy_system && isParamValid("solid_energy_system")),
     _solid_energy_l_abs_tol(getParam<Real>("solid_energy_l_abs_tol")),
     _passive_scalar_system_names(getParam<std::vector<SolverSystemName>>("passive_scalar_systems")),
     _has_passive_scalar_systems(!_passive_scalar_system_names.empty()),
     _passive_scalar_equation_relaxation(
         getParam<std::vector<Real>>("passive_scalar_equation_relaxation")),
     _passive_scalar_l_abs_tol(getParam<Real>("passive_scalar_l_abs_tol")),
     _turbulence_system_names(getParam<std::vector<SolverSystemName>>("turbulence_systems")),
     _has_turbulence_systems(!_turbulence_system_names.empty()),
     _turbulence_equation_relaxation(getParam<std::vector<Real>>("turbulence_equation_relaxation")),
     _turbulence_field_relaxation(getParam<std::vector<Real>>("turbulence_field_relaxation")),
     _turbulence_field_min_limit(getParam<std::vector<Real>>("turbulence_field_min_limit")),
     _turbulence_l_abs_tol(getParam<Real>("turbulence_l_abs_tol")),
     _momentum_absolute_tolerance(getParam<Real>("momentum_absolute_tolerance")),
     _pressure_absolute_tolerance(getParam<Real>("pressure_absolute_tolerance")),
     _energy_absolute_tolerance(getParam<Real>("energy_absolute_tolerance")),
     _solid_energy_absolute_tolerance(getParam<Real>("solid_energy_absolute_tolerance")),
     _passive_scalar_absolute_tolerance(
         getParam<std::vector<Real>>("passive_scalar_absolute_tolerance")),
     _turbulence_absolute_tolerance(getParam<std::vector<Real>>("turbulence_absolute_tolerance")),
     _num_iterations(getParam<unsigned int>("num_iterations")),
     _continue_on_max_its(getParam<bool>("continue_on_max_its")),
     _print_fields(getParam<bool>("print_fields"))
 {
   if (_momentum_system_names.size() != _problem.mesh().dimension())
     paramError("momentum_systems",
                "The number of momentum components should be equal to the number of "
                "spatial dimensions on the mesh.");
 
   const auto & momentum_petsc_options = getParam<MultiMooseEnum>("momentum_petsc_options");
   const auto & momentum_petsc_pair_options = getParam<MooseEnumItem, std::string>(
       "momentum_petsc_options_iname", "momentum_petsc_options_value");
   Moose::PetscSupport::addPetscFlagsToPetscOptions(
       momentum_petsc_options, "", *this, _momentum_petsc_options);
   Moose::PetscSupport::addPetscPairsToPetscOptions(
       momentum_petsc_pair_options, _problem.mesh().dimension(), "", *this, _momentum_petsc_options);
 
   _momentum_linear_control.real_valued_data["rel_tol"] = getParam<Real>("momentum_l_tol");
   _momentum_linear_control.real_valued_data["abs_tol"] = getParam<Real>("momentum_l_abs_tol");
   _momentum_linear_control.int_valued_data["max_its"] =
       getParam<unsigned int>("momentum_l_max_its");
 
   const auto & pressure_petsc_options = getParam<MultiMooseEnum>("pressure_petsc_options");
   const auto & pressure_petsc_pair_options = getParam<MooseEnumItem, std::string>(
       "pressure_petsc_options_iname", "pressure_petsc_options_value");
   Moose::PetscSupport::addPetscFlagsToPetscOptions(
       pressure_petsc_options, "", *this, _pressure_petsc_options);
   Moose::PetscSupport::addPetscPairsToPetscOptions(
       pressure_petsc_pair_options, _problem.mesh().dimension(), "", *this, _pressure_petsc_options);
 
   _pressure_linear_control.real_valued_data["rel_tol"] = getParam<Real>("pressure_l_tol");
   _pressure_linear_control.real_valued_data["abs_tol"] = getParam<Real>("pressure_l_abs_tol");
   _pressure_linear_control.int_valued_data["max_its"] =
       getParam<unsigned int>("pressure_l_max_its");
 
   if (_has_energy_system)
   {
     const auto & energy_petsc_options = getParam<MultiMooseEnum>("energy_petsc_options");
     const auto & energy_petsc_pair_options = getParam<MooseEnumItem, std::string>(
         "energy_petsc_options_iname", "energy_petsc_options_value");
     Moose::PetscSupport::addPetscFlagsToPetscOptions(
         energy_petsc_options, "", *this, _energy_petsc_options);
     Moose::PetscSupport::addPetscPairsToPetscOptions(
         energy_petsc_pair_options, _problem.mesh().dimension(), "", *this, _energy_petsc_options);
 
     _energy_linear_control.real_valued_data["rel_tol"] = getParam<Real>("energy_l_tol");
     _energy_linear_control.real_valued_data["abs_tol"] = getParam<Real>("energy_l_abs_tol");
     _energy_linear_control.int_valued_data["max_its"] = getParam<unsigned int>("energy_l_max_its");
   }
   else
     checkDependentParameterError("energy_system",
                                  {"energy_petsc_options",
                                   "energy_petsc_options_iname",
                                   "energy_petsc_options_value",
                                   "energy_l_tol",
                                   "energy_l_abs_tol",
                                   "energy_l_max_its",
                                   "energy_absolute_tolerance",
                                   "energy_equation_relaxation"},
                                  false);
 
   if (_has_solid_energy_system)
   {
     const auto & solid_energy_petsc_options =
         getParam<MultiMooseEnum>("solid_energy_petsc_options");
     const auto & solid_energy_petsc_pair_options = getParam<MooseEnumItem, std::string>(
         "solid_energy_petsc_options_iname", "solid_energy_petsc_options_value");
     Moose::PetscSupport::addPetscFlagsToPetscOptions(
         solid_energy_petsc_options, "", *this, _solid_energy_petsc_options);
     Moose::PetscSupport::addPetscPairsToPetscOptions(solid_energy_petsc_pair_options,
                                                      _problem.mesh().dimension(),
                                                      "",
                                                      *this,
                                                      _solid_energy_petsc_options);
 
     _solid_energy_linear_control.real_valued_data["rel_tol"] = getParam<Real>("solid_energy_l_tol");
     _solid_energy_linear_control.real_valued_data["abs_tol"] =
         getParam<Real>("solid_energy_l_abs_tol");
     _solid_energy_linear_control.int_valued_data["max_its"] =
         getParam<unsigned int>("solid_energy_l_max_its");
   }
   else
     checkDependentParameterError("solid_energy_system",
                                  {"solid_energy_petsc_options",
                                   "solid_energy_petsc_options_iname",
                                   "solid_energy_petsc_options_value",
                                   "solid_energy_l_tol",
                                   "solid_energy_l_abs_tol",
                                   "solid_energy_l_max_its",
                                   "solid_energy_absolute_tolerance",
                                   "solid_energy_equation_relaxation"},
                                  false);
 
   // We check for input errors with regards to the passive scalar equations. At the same time, we
   // set up the corresponding system numbers
   if (_has_passive_scalar_systems)
   {
     if (_passive_scalar_system_names.size() != _passive_scalar_equation_relaxation.size())
       paramError("passive_scalar_equation_relaxation",
                  "The number of equation relaxation parameters does not match the number of "
                  "passive scalar equations!");
     if (_passive_scalar_system_names.size() != _passive_scalar_absolute_tolerance.size())
       paramError("passive_scalar_absolute_tolerance",
                  "The number of absolute tolerances does not match the number of "
                  "passive scalar equations!");
   }
   if (_has_passive_scalar_systems)
   {
     const auto & passive_scalar_petsc_options =
         getParam<MultiMooseEnum>("passive_scalar_petsc_options");
     const auto & passive_scalar_petsc_pair_options = getParam<MooseEnumItem, std::string>(
         "passive_scalar_petsc_options_iname", "passive_scalar_petsc_options_value");
     Moose::PetscSupport::addPetscFlagsToPetscOptions(
         passive_scalar_petsc_options, "", *this, _passive_scalar_petsc_options);
     Moose::PetscSupport::addPetscPairsToPetscOptions(passive_scalar_petsc_pair_options,
                                                      _problem.mesh().dimension(),
                                                      "",
                                                      *this,
                                                      _passive_scalar_petsc_options);
 
     _passive_scalar_linear_control.real_valued_data["rel_tol"] =
         getParam<Real>("passive_scalar_l_tol");
     _passive_scalar_linear_control.real_valued_data["abs_tol"] =
         getParam<Real>("passive_scalar_l_abs_tol");
     _passive_scalar_linear_control.int_valued_data["max_its"] =
         getParam<unsigned int>("passive_scalar_l_max_its");
   }
   else
     checkDependentParameterError("passive_scalar_systems",
                                  {"passive_scalar_petsc_options",
                                   "passive_scalar_petsc_options_iname",
                                   "passive_scalar_petsc_options_value",
                                   "passive_scalar_l_tol",
                                   "passive_scalar_l_abs_tol",
                                   "passive_scalar_l_max_its",
                                   "passive_scalar_equation_relaxation",
                                   "passive_scalar_absolute_tolerance"},
                                  false);
 
   // We check for input errors with regards to the surrogate turbulence equations. At the same time,
   // we set up the corresponding system numbers
   if (_has_turbulence_systems)
   {
     if (_turbulence_system_names.size() != _turbulence_equation_relaxation.size())
       paramError("turbulence_equation_relaxation",
                  "The number of equation relaxation parameters does not match the number of "
                  "turbulence equations!");
     if (_turbulence_system_names.size() != _turbulence_absolute_tolerance.size())
       paramError("turbulence_absolute_tolerance",
                  "The number of absolute tolerances does not match the number of "
                  "turbulence equations!");
     if (_turbulence_field_min_limit.empty())
       // If no minimum bounds are given, initialize to default value 1e-8
       _turbulence_field_min_limit.resize(_turbulence_system_names.size(), 1e-8);
 
     // Assign turbulence field relaxation as 1.0 if not defined
     if (_turbulence_field_relaxation.empty())
       _turbulence_field_relaxation.resize(_turbulence_system_names.size(), 1.0);
 
     const auto & turbulence_petsc_options = getParam<MultiMooseEnum>("turbulence_petsc_options");
     const auto & turbulence_petsc_pair_options = getParam<MooseEnumItem, std::string>(
         "turbulence_petsc_options_iname", "turbulence_petsc_options_value");
     Moose::PetscSupport::addPetscFlagsToPetscOptions(
         turbulence_petsc_options, "", *this, _turbulence_petsc_options);
     Moose::PetscSupport::addPetscPairsToPetscOptions(turbulence_petsc_pair_options,
                                                      _problem.mesh().dimension(),
                                                      "",
                                                      *this,
                                                      _turbulence_petsc_options);
 
     _turbulence_linear_control.real_valued_data["rel_tol"] = getParam<Real>("turbulence_l_tol");
     _turbulence_linear_control.real_valued_data["abs_tol"] = getParam<Real>("turbulence_l_abs_tol");
     _turbulence_linear_control.int_valued_data["max_its"] =
         getParam<unsigned int>("turbulence_l_max_its");
   }
   else
     checkDependentParameterError("turbulence_systems",
                                  {"turbulence_petsc_options",
                                   "turbulence_petsc_options_iname",
                                   "turbulence_petsc_options_value",
                                   "turbulence_l_tol",
                                   "turbulence_l_abs_tol",
                                   "turbulence_l_max_its",
                                   "turbulence_equation_relaxation",
                                   "turbulence_field_relaxation",
                                   "turbulence_field_min_limit",
                                   "turbulence_absolute_tolerance"},
                                  false);
 }

Member Function Documentation

◆ checkDependentParameterError()

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

protected

Definition at line 600 of file SIMPLESolveBase.C.

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

 {
   for (const auto & param : dependent_parameters)
     if (parameters().isParamSetByUser(param) == !should_be_defined)
       paramError(param,
                  "This parameter should " + std::string(should_be_defined ? "" : "not") +
                      " be given by the user with the corresponding " + main_parameter +
                      " setting!");
 }

◆ checkIntegrity()

virtual void SIMPLESolveBase::checkIntegrity ( )

inlinevirtual

Check if the user defined time kernels.

Reimplemented in SIMPLESolve, and SIMPLESolveNonlinearAssembly.

Definition at line 61 of file SIMPLESolveBase.h.

61 {}

◆ linkRhieChowUserObject()

virtual void SIMPLESolveBase::linkRhieChowUserObject ( )

pure virtual

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

Implemented in LinearAssemblySegregatedSolve, and SIMPLESolveNonlinearAssembly.

◆ setInnerSolve()

virtual void SIMPLESolveBase::setInnerSolve ( SolveObject & )

inlineoverridevirtual

Reimplemented from SolveObject.

Definition at line 48 of file SIMPLESolveBase.h.

   {
     mooseError("Cannot set inner solve object for solves that inherit from SIMPLESolveBase");
   }

◆ setupPressurePin()

void SIMPLESolveBase::setupPressurePin ( )

Setup pressure pin if there is need for one.

Definition at line 591 of file SIMPLESolveBase.C.

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

 {
   if (_pin_pressure)
     _pressure_pin_dof = NS::FV::findPointDoFID(_problem.getVariable(0, "pressure"),
                                                _problem.mesh(),
                                                getParam<Point>("pressure_pin_point"));
 }

◆ solveMomentumPredictor()

virtual std::vector<std::pair<unsigned int, Real> > SIMPLESolveBase::solveMomentumPredictor ( )

protectedpure virtual

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.

Implemented in LinearAssemblySegregatedSolve, and SIMPLESolveNonlinearAssembly.

◆ solvePressureCorrector()

virtual std::pair<unsigned int, Real> SIMPLESolveBase::solvePressureCorrector ( )

protectedpure virtual

Solve a pressure corrector step.

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

Implemented in LinearAssemblySegregatedSolve, and SIMPLESolveNonlinearAssembly.

◆ validParams()

InputParameters SIMPLESolveBase::validParams ( )

static

Definition at line 15 of file SIMPLESolveBase.C.

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

 {
   InputParameters params = emptyInputParameters();
   params.addRequiredParam<UserObjectName>("rhie_chow_user_object", "The rhie-chow user-object");
 
   /*
    * The names of the different systems in the segregated solver
    */
   params.addRequiredParam<std::vector<SolverSystemName>>(
       "momentum_systems", "The solver system(s) for the momentum equation(s).");
   params.addRequiredParam<SolverSystemName>("pressure_system",
                                             "The solver system for the pressure equation.");
   params.addParam<SolverSystemName>("energy_system", "The solver system for the energy equation.");
   params.addParam<SolverSystemName>("solid_energy_system",
                                     "The solver system for the solid energy equation.");
   params.addParam<std::vector<SolverSystemName>>(
       "passive_scalar_systems", {}, "The solver system for each scalar advection equation.");
   params.addParam<std::vector<SolverSystemName>>(
       "turbulence_systems", {}, "The solver system for each surrogate turbulence equation.");
 
   /*
    * Parameters to control the solution of the momentum equation
    */
 
   params.addRangeCheckedParam<Real>(
       "momentum_equation_relaxation",
       1.0,
       "0.0<momentum_equation_relaxation<=1.0",
       "The relaxation which should be used for the momentum equation. (=1 for no relaxation, "
       "diagonal dominance will still be enforced)");
 
   params.addParam<MultiMooseEnum>("momentum_petsc_options",
                                   Moose::PetscSupport::getCommonPetscFlags(),
                                   "Singleton PETSc options for the momentum equation");
   params.addParam<MultiMooseEnum>("momentum_petsc_options_iname",
                                   Moose::PetscSupport::getCommonPetscKeys(),
                                   "Names of PETSc name/value pairs for the momentum equation");
   params.addParam<std::vector<std::string>>(
       "momentum_petsc_options_value",
       "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
       "momentum equation");
 
   params.addRangeCheckedParam<Real>(
       "momentum_absolute_tolerance",
       1e-5,
       "0.0<momentum_absolute_tolerance",
       "The absolute tolerance on the normalized residual of the momentum equation.");
 
   params.addRangeCheckedParam<Real>("momentum_l_tol",
                                     1e-5,
                                     "0.0<=momentum_l_tol & momentum_l_tol<1.0",
                                     "The relative tolerance on the normalized residual in the "
                                     "linear solver of the momentum equation.");
   params.addRangeCheckedParam<Real>("momentum_l_abs_tol",
                                     1e-50,
                                     "0.0<momentum_l_abs_tol",
                                     "The absolute tolerance on the normalized residual in the "
                                     "linear solver of the momentum equation.");
   params.addParam<unsigned int>(
       "momentum_l_max_its",
       10000,
       "The maximum allowed iterations in the linear solver of the momentum equation.");
 
   params.addParamNamesToGroup(
       "momentum_equation_relaxation momentum_petsc_options momentum_petsc_options_iname "
       "momentum_petsc_options_value momentum_petsc_options_value momentum_absolute_tolerance "
       "momentum_l_tol momentum_l_abs_tol momentum_l_max_its momentum_systems",
       "Momentum Equation");
 
   /*
    * Parameters to control the solution of the pressure equation
    */
   params.addRangeCheckedParam<Real>(
       "pressure_variable_relaxation",
       1.0,
       "0.0<pressure_variable_relaxation<=1.0",
       "The relaxation which should be used for the pressure variable (=1 for no relaxation).");
 
   params.addParam<MultiMooseEnum>("pressure_petsc_options",
                                   Moose::PetscSupport::getCommonPetscFlags(),
                                   "Singleton PETSc options for the pressure equation");
   params.addParam<MultiMooseEnum>("pressure_petsc_options_iname",
                                   Moose::PetscSupport::getCommonPetscKeys(),
                                   "Names of PETSc name/value pairs for the pressure equation");
   params.addParam<std::vector<std::string>>(
       "pressure_petsc_options_value",
       "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
       "pressure equation");
 
   params.addRangeCheckedParam<Real>(
       "pressure_absolute_tolerance",
       1e-5,
       "0.0<pressure_absolute_tolerance",
       "The absolute tolerance on the normalized residual of the pressure equation.");
 
   params.addRangeCheckedParam<Real>("pressure_l_tol",
                                     1e-5,
                                     "0.0<=pressure_l_tol & pressure_l_tol<1.0",
                                     "The relative tolerance on the normalized residual in the "
                                     "linear solver of the pressure equation.");
   params.addRangeCheckedParam<Real>("pressure_l_abs_tol",
                                     1e-10,
                                     "0.0<pressure_l_abs_tol",
                                     "The absolute tolerance on the normalized residual in the "
                                     "linear solver of the pressure equation.");
   params.addParam<unsigned int>(
       "pressure_l_max_its",
       10000,
       "The maximum allowed iterations in the linear solver of the pressure equation.");
 
   params.addParamNamesToGroup(
       "pressure_variable_relaxation pressure_petsc_options pressure_petsc_options_iname "
       "pressure_petsc_options_value pressure_petsc_options_value pressure_absolute_tolerance "
       "pressure_l_tol pressure_l_abs_tol pressure_l_max_its pressure_system",
       "Pressure Equation");
 
   /*
    * Pressure pin parameters for enclosed flows
    */
 
   params.addParam<bool>(
       "pin_pressure", false, "If the pressure field needs to be pinned at a point.");
   params.addParam<Real>(
       "pressure_pin_value", 0.0, "The value which needs to be enforced for the pressure.");
   params.addParam<Point>("pressure_pin_point", "The point where the pressure needs to be pinned.");
 
   params.addParamNamesToGroup("pin_pressure pressure_pin_value pressure_pin_point", "Pressure Pin");
 
   params.addParam<bool>(
       "print_fields",
       false,
       "Use this to print the coupling and solution fields and matrices throughout the iteration.");
 
   /*
    * Parameters to control the solution of the energy equation
    */
 
   params.addRangeCheckedParam<Real>(
       "energy_equation_relaxation",
       1.0,
       "0.0<energy_equation_relaxation<=1.0",
       "The relaxation which should be used for the energy equation. (=1 for no relaxation, "
       "diagonal dominance will still be enforced)");
 
   params.addParam<MultiMooseEnum>("energy_petsc_options",
                                   Moose::PetscSupport::getCommonPetscFlags(),
                                   "Singleton PETSc options for the energy equation");
   params.addParam<MultiMooseEnum>("energy_petsc_options_iname",
                                   Moose::PetscSupport::getCommonPetscKeys(),
                                   "Names of PETSc name/value pairs for the energy equation");
   params.addParam<std::vector<std::string>>(
       "energy_petsc_options_value",
       "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
       "energy equation");
 
   params.addRangeCheckedParam<Real>(
       "energy_absolute_tolerance",
       1e-5,
       "0.0<energy_absolute_tolerance",
       "The absolute tolerance on the normalized residual of the energy equation.");
 
   params.addRangeCheckedParam<Real>("energy_l_tol",
                                     1e-5,
                                     "0.0<=energy_l_tol & energy_l_tol<1.0",
                                     "The relative tolerance on the normalized residual in the "
                                     "linear solver of the energy equation.");
   params.addRangeCheckedParam<Real>("energy_l_abs_tol",
                                     1e-10,
                                     "0.0<energy_l_abs_tol",
                                     "The absolute tolerance on the normalized residual in the "
                                     "linear solver of the energy equation.");
   params.addRangeCheckedParam<unsigned int>(
       "energy_l_max_its",
       10000,
       "0<energy_l_max_its",
       "The maximum allowed iterations in the linear solver of the energy equation.");
 
   params.addParamNamesToGroup(
       "energy_equation_relaxation energy_petsc_options energy_petsc_options_iname "
       "energy_petsc_options_value energy_petsc_options_value energy_absolute_tolerance "
       "energy_l_tol energy_l_abs_tol energy_l_max_its",
       "Energy Equation");
 
   /*
    * Parameters to control the solution of the solid energy equation
    */
 
   params.addParam<MultiMooseEnum>("solid_energy_petsc_options",
                                   Moose::PetscSupport::getCommonPetscFlags(),
                                   "Singleton PETSc options for the solid energy equation");
   params.addParam<MultiMooseEnum>("solid_energy_petsc_options_iname",
                                   Moose::PetscSupport::getCommonPetscKeys(),
                                   "Names of PETSc name/value pairs for the solid energy equation");
   params.addParam<std::vector<std::string>>(
       "solid_energy_petsc_options_value",
       "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
       "solid energy equation");
 
   params.addRangeCheckedParam<Real>(
       "solid_energy_absolute_tolerance",
       1e-5,
       "0.0<solid_energy_absolute_tolerance",
       "The absolute tolerance on the normalized residual of the solid energy equation.");
 
   params.addRangeCheckedParam<Real>("solid_energy_l_tol",
                                     1e-5,
                                     "0.0<=solid_energy_l_tol & solid_energy_l_tol<1.0",
                                     "The relative tolerance on the normalized residual in the "
                                     "linear solver of the solid energy equation.");
 
   params.addRangeCheckedParam<Real>("solid_energy_l_abs_tol",
                                     1e-10,
                                     "0.0<solid_energy_l_abs_tol",
                                     "The absolute tolerance on the normalized residual in the "
                                     "linear solver of the solid energy equation.");
   params.addRangeCheckedParam<unsigned int>(
       "solid_energy_l_max_its",
       10000,
       "0<solid_energy_l_max_its",
       "The maximum allowed iterations in the linear solver of the solid energy equation.");
 
   params.addParamNamesToGroup("solid_energy_petsc_options solid_energy_petsc_options_iname "
                               "solid_energy_petsc_options_value solid_energy_absolute_tolerance "
                               "solid_energy_l_tol solid_energy_l_abs_tol solid_energy_l_max_its",
                               "Solid Energy Equation");
 
   /*
    * Parameters to control the solution of each scalar advection system
    */
   params.addParam<std::vector<Real>>("passive_scalar_equation_relaxation",
                                      std::vector<Real>(),
                                      "The relaxation which should be used for the passive scalar "
                                      "equations. (=1 for no relaxation, "
                                      "diagonal dominance will still be enforced)");
 
   params.addParam<MultiMooseEnum>("passive_scalar_petsc_options",
                                   Moose::PetscSupport::getCommonPetscFlags(),
                                   "Singleton PETSc options for the passive scalar equation(s)");
   params.addParam<MultiMooseEnum>(
       "passive_scalar_petsc_options_iname",
       Moose::PetscSupport::getCommonPetscKeys(),
       "Names of PETSc name/value pairs for the passive scalar equation(s)");
   params.addParam<std::vector<std::string>>(
       "passive_scalar_petsc_options_value",
       "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
       "passive scalar equation(s)");
   params.addParam<std::vector<Real>>(
       "passive_scalar_absolute_tolerance",
       std::vector<Real>(),
       "The absolute tolerance(s) on the normalized residual(s) of the passive scalar equation(s).");
   params.addRangeCheckedParam<Real>("passive_scalar_l_tol",
                                     1e-5,
                                     "0.0<=passive_scalar_l_tol & passive_scalar_l_tol<1.0",
                                     "The relative tolerance on the normalized residual in the "
                                     "linear solver of the passive scalar equation(s).");
   params.addRangeCheckedParam<Real>("passive_scalar_l_abs_tol",
                                     1e-10,
                                     "0.0<passive_scalar_l_abs_tol",
                                     "The absolute tolerance on the normalized residual in the "
                                     "linear solver of the passive scalar equation(s).");
   params.addParam<unsigned int>(
       "passive_scalar_l_max_its",
       10000,
       "The maximum allowed iterations in the linear solver of the turbulence equation.");
 
   params.addParamNamesToGroup(
       "passive_scalar_systems passive_scalar_equation_relaxation passive_scalar_petsc_options "
       "passive_scalar_petsc_options_iname "
       "passive_scalar_petsc_options_value passive_scalar_petsc_options_value "
       "passive_scalar_absolute_tolerance "
       "passive_scalar_l_tol passive_scalar_l_abs_tol passive_scalar_l_max_its",
       "passive_scalar Equation");
 
   /*
    * Parameters to control the solution of each turbulence system
    */
   params.addParam<std::vector<Real>>("turbulence_equation_relaxation",
                                      std::vector<Real>(),
                                      "The relaxation which should be used for the turbulence "
                                      "equations. (=1 for no relaxation, "
                                      "diagonal dominance will still be enforced)");
 
   params.addParam<std::vector<Real>>("turbulence_field_relaxation",
                                      std::vector<Real>(),
                                      "The relaxation which should be used for the turbulence "
                                      "fields.");
 
   params.addParam<std::vector<Real>>(
       "turbulence_field_min_limit",
       std::vector<Real>(),
       "The lower limit imposed on turbulent quantities. The recommended value for robustness "
       "is 1e-8. This is the imposed default if not set.");
 
   params.addParam<MultiMooseEnum>("turbulence_petsc_options",
                                   Moose::PetscSupport::getCommonPetscFlags(),
                                   "Singleton PETSc options for the turbulence equation(s)");
   params.addParam<MultiMooseEnum>("turbulence_petsc_options_iname",
                                   Moose::PetscSupport::getCommonPetscKeys(),
                                   "Names of PETSc name/value pairs for the turbulence equation(s)");
   params.addParam<std::vector<std::string>>(
       "turbulence_petsc_options_value",
       "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
       "turbulence equation(s)");
   params.addParam<std::vector<Real>>(
       "turbulence_absolute_tolerance",
       std::vector<Real>(),
       "The absolute tolerance(s) on the normalized residual(s) of the turbulence equation(s).");
   params.addRangeCheckedParam<Real>("turbulence_l_tol",
                                     1e-5,
                                     "0.0<=turbulence_l_tol & turbulence_l_tol<1.0",
                                     "The relative tolerance on the normalized residual in the "
                                     "linear solver of the turbulence equation(s).");
   params.addRangeCheckedParam<Real>("turbulence_l_abs_tol",
                                     1e-10,
                                     "0.0<turbulence_l_abs_tol",
                                     "The absolute tolerance on the normalized residual in the "
                                     "linear solver of the turbulence equation(s).");
   params.addParam<unsigned int>(
       "turbulence_l_max_its",
       10000,
       "The maximum allowed iterations in the linear solver of the turbulence equation.");
 
   params.addParamNamesToGroup("turbulence_systems "
                               "turbulence_equation_relaxation "
                               "turbulence_field_relaxation "
                               "turbulence_field_min_limit "
                               "turbulence_petsc_options "
                               "turbulence_petsc_options_iname "
                               "turbulence_petsc_options_value turbulence_petsc_options_value "
                               "turbulence_absolute_tolerance "
                               "turbulence_l_tol turbulence_l_abs_tol turbulence_l_max_its",
                               "Turbulence Equations");
 
   /*
    * SIMPLE iteration control
    */
 
   params.addRangeCheckedParam<unsigned int>(
       "num_iterations",
       1000,
       "0<num_iterations",
       "The number of momentum-pressure-(other fields) iterations needed.");
 
   params.addParam<bool>("continue_on_max_its",
                         false,
                         "If solve should continue if maximum number of iterations is hit.");
 
   return params;
 }

Member Data Documentation

◆ _continue_on_max_its

const bool SIMPLESolveBase::_continue_on_max_its

protected

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

Definition at line 235 of file SIMPLESolveBase.h.

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

◆ _energy_absolute_tolerance

const Real SIMPLESolveBase::_energy_absolute_tolerance

protected

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

Definition at line 220 of file SIMPLESolveBase.h.

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

◆ _energy_equation_relaxation

const Real SIMPLESolveBase::_energy_equation_relaxation

protected

The user-defined relaxation parameter for the energy equation.

Definition at line 130 of file SIMPLESolveBase.h.

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

◆ _energy_l_abs_tol

const Real SIMPLESolveBase::_energy_l_abs_tol

protected

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 LinearAssemblySegregatedSolve::solve(), and SIMPLESolveNonlinearAssembly::solve().

◆ _energy_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_energy_linear_control

protected

Options for the linear solver of the energy equation.

Definition at line 136 of file SIMPLESolveBase.h.

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

◆ _energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_energy_petsc_options

protected

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

Definition at line 133 of file SIMPLESolveBase.h.

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

◆ _has_energy_system

const bool SIMPLESolveBase::_has_energy_system

protected

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

Definition at line 127 of file SIMPLESolveBase.h.

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

◆ _has_passive_scalar_systems

const bool SIMPLESolveBase::_has_passive_scalar_systems

protected

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

Definition at line 163 of file SIMPLESolveBase.h.

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

◆ _has_solid_energy_system

const bool SIMPLESolveBase::_has_solid_energy_system

protected

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(), SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and LinearAssemblySegregatedSolve::solve().

◆ _has_turbulence_systems

const bool SIMPLESolveBase::_has_turbulence_systems

protected

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

Definition at line 187 of file SIMPLESolveBase.h.

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

◆ _momentum_absolute_tolerance

const Real SIMPLESolveBase::_momentum_absolute_tolerance

protected

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

Definition at line 214 of file SIMPLESolveBase.h.

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

◆ _momentum_equation_relaxation

const Real SIMPLESolveBase::_momentum_equation_relaxation

protected

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

protected

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

protected

Options for the linear solver of the momentum equation.

Definition at line 85 of file SIMPLESolveBase.h.

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

◆ _momentum_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_momentum_petsc_options

protected

Options which hold the petsc settings for the momentum equation.

Definition at line 92 of file SIMPLESolveBase.h.

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

◆ _momentum_system_names

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

protected

The names of the momentum systems.

Definition at line 82 of file SIMPLESolveBase.h.

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

◆ _num_iterations

const unsigned int SIMPLESolveBase::_num_iterations

protected

The maximum number of momentum-pressure iterations.

Definition at line 232 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_absolute_tolerance

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

protected

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

Definition at line 226 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_equation_relaxation

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

protected

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

Definition at line 169 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_l_abs_tol

const Real SIMPLESolveBase::_passive_scalar_l_abs_tol

protected

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 LinearAssemblySegregatedSolve::solve(), and SIMPLESolveNonlinearAssembly::solve().

◆ _passive_scalar_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_passive_scalar_linear_control

protected

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

Definition at line 175 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_passive_scalar_petsc_options

protected

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

Definition at line 172 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_system_names

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

protected

The names of the passive scalar systems.

Definition at line 160 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_system_numbers

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

protected

Definition at line 166 of file SIMPLESolveBase.h.

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

◆ _pin_pressure

const bool SIMPLESolveBase::_pin_pressure

protected

If the pressure needs to be pinned.

Definition at line 116 of file SIMPLESolveBase.h.

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

◆ _pressure_absolute_tolerance

const Real SIMPLESolveBase::_pressure_absolute_tolerance

protected

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

Definition at line 217 of file SIMPLESolveBase.h.

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

◆ _pressure_l_abs_tol

const Real SIMPLESolveBase::_pressure_l_abs_tol

protected

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

protected

Options for the linear solver of the pressure equation.

Definition at line 103 of file SIMPLESolveBase.h.

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

◆ _pressure_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_pressure_petsc_options

protected

Options which hold the petsc settings for the pressure equation.

Definition at line 110 of file SIMPLESolveBase.h.

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

◆ _pressure_pin_dof

dof_id_type SIMPLESolveBase::_pressure_pin_dof

protected

The dof ID where the pressure needs to be pinned.

Definition at line 122 of file SIMPLESolveBase.h.

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

◆ _pressure_pin_value

const Real SIMPLESolveBase::_pressure_pin_value

protected

The value we want to enforce for pressure.

Definition at line 119 of file SIMPLESolveBase.h.

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

◆ _pressure_system_name

const SolverSystemName& SIMPLESolveBase::_pressure_system_name

protected

The name of the pressure system.

Definition at line 100 of file SIMPLESolveBase.h.

◆ _pressure_variable_relaxation

const Real SIMPLESolveBase::_pressure_variable_relaxation

protected

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

protected

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

Definition at line 240 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().

◆ _solid_energy_absolute_tolerance

const Real SIMPLESolveBase::_solid_energy_absolute_tolerance

protected

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

Definition at line 223 of file SIMPLESolveBase.h.

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

◆ _solid_energy_l_abs_tol

const Real SIMPLESolveBase::_solid_energy_l_abs_tol

protected

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

protected

Options for the linear solver of the energy equation.

Definition at line 151 of file SIMPLESolveBase.h.

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

◆ _solid_energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_solid_energy_petsc_options

protected

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

Definition at line 148 of file SIMPLESolveBase.h.

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

◆ _turbulence_absolute_tolerance

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

protected

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

Definition at line 229 of file SIMPLESolveBase.h.

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

◆ _turbulence_equation_relaxation

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

protected

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

Definition at line 193 of file SIMPLESolveBase.h.

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

◆ _turbulence_field_min_limit

std::vector<Real> SIMPLESolveBase::_turbulence_field_min_limit

protected

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

Definition at line 199 of file SIMPLESolveBase.h.

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

◆ _turbulence_field_relaxation

std::vector<Real> SIMPLESolveBase::_turbulence_field_relaxation

protected

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

Definition at line 196 of file SIMPLESolveBase.h.

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

◆ _turbulence_l_abs_tol

const Real SIMPLESolveBase::_turbulence_l_abs_tol

protected

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 209 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _turbulence_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_turbulence_linear_control

protected

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

Definition at line 205 of file SIMPLESolveBase.h.

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

◆ _turbulence_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_turbulence_petsc_options

protected

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

Definition at line 202 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_names

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

protected

The names of the turbulence systems.

Definition at line 184 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_numbers

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

protected

Definition at line 190 of file SIMPLESolveBase.h.

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

The documentation for this class was generated from the following files:

navier_stokes/include/executioners/SIMPLESolveBase.h
navier_stokes/src/executioners/SIMPLESolveBase.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SIMPLESolveBase()

Member Function Documentation

◆ checkDependentParameterError()

◆ checkIntegrity()

◆ linkRhieChowUserObject()

◆ setInnerSolve()

◆ setupPressurePin()

◆ solveMomentumPredictor()

◆ solvePressureCorrector()

◆ validParams()

Member Data Documentation

◆ _continue_on_max_its

◆ _energy_absolute_tolerance

◆ _energy_equation_relaxation

◆ _energy_l_abs_tol

◆ _energy_linear_control

◆ _energy_petsc_options

◆ _has_energy_system

◆ _has_passive_scalar_systems

◆ _has_solid_energy_system

◆ _has_turbulence_systems

◆ _momentum_absolute_tolerance

◆ _momentum_equation_relaxation

◆ _momentum_l_abs_tol

◆ _momentum_linear_control

◆ _momentum_petsc_options

◆ _momentum_system_names

◆ _num_iterations

◆ _passive_scalar_absolute_tolerance

◆ _passive_scalar_equation_relaxation

◆ _passive_scalar_l_abs_tol

◆ _passive_scalar_linear_control

◆ _passive_scalar_petsc_options

◆ _passive_scalar_system_names

◆ _passive_scalar_system_numbers

◆ _pin_pressure

◆ _pressure_absolute_tolerance

◆ _pressure_l_abs_tol

◆ _pressure_linear_control

◆ _pressure_petsc_options

◆ _pressure_pin_dof

◆ _pressure_pin_value

◆ _pressure_system_name

◆ _pressure_variable_relaxation

◆ _print_fields

◆ _solid_energy_absolute_tolerance

◆ _solid_energy_l_abs_tol

◆ _solid_energy_linear_control

◆ _solid_energy_petsc_options

◆ _turbulence_absolute_tolerance

◆ _turbulence_equation_relaxation

◆ _turbulence_field_min_limit

◆ _turbulence_field_relaxation

◆ _turbulence_l_abs_tol

◆ _turbulence_linear_control

◆ _turbulence_petsc_options

◆ _turbulence_system_names

◆ _turbulence_system_numbers