Common base class for segregated solvers for the Navier-Stokes equations with linear FV assembly routines. More...

#include <LinearAssemblySegregatedSolve.h>

Inheritance diagram for LinearAssemblySegregatedSolve:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	LinearAssemblySegregatedSolve (Executioner &ex)

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

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 void	checkIntegrity ()
	Check if the user defined time kernels. More...

virtual void	initialSetup ()

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &nm) 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

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

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

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

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

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

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

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

void	mooseInfo (Args &&... args) 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 ()

Public Attributes
const ConsoleStream	_console

Protected Member Functions
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...

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)

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
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 nonlinear 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 nonlinear 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 nonlinear 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 * >	_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 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...

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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Detailed Description

Common base class for segregated solvers for the Navier-Stokes equations with linear FV assembly routines.

Once the nonlinear assembly-based routines are retired, this will be the primary base class instead of SIMPLESolveBase.

Definition at line 22 of file LinearAssemblySegregatedSolve.h.

Constructor & Destructor Documentation

◆ LinearAssemblySegregatedSolve()

LinearAssemblySegregatedSolve::LinearAssemblySegregatedSolve ( Executioner & ex )

Definition at line 75 of file LinearAssemblySegregatedSolve.C.

   : SIMPLESolveBase(ex),
     _pressure_sys_number(_problem.linearSysNum(getParam<SolverSystemName>("pressure_system"))),
     _pressure_system(_problem.getLinearSystem(_pressure_sys_number)),
     _energy_sys_number(_has_energy_system
                            ? _problem.linearSysNum(getParam<SolverSystemName>("energy_system"))
                            : libMesh::invalid_uint),
     _energy_system(_has_energy_system ? &_problem.getLinearSystem(_energy_sys_number) : nullptr),
     _solid_energy_sys_number(
         _has_solid_energy_system
             ? _problem.linearSysNum(getParam<SolverSystemName>("solid_energy_system"))
             : libMesh::invalid_uint),
     _solid_energy_system(
         _has_solid_energy_system ? &_problem.getLinearSystem(_solid_energy_sys_number) : nullptr),
     _active_scalar_system_names(getParam<std::vector<SolverSystemName>>("active_scalar_systems")),
     _has_active_scalar_systems(!_active_scalar_system_names.empty()),
     _active_scalar_equation_relaxation(
         getParam<std::vector<Real>>("active_scalar_equation_relaxation")),
     _active_scalar_l_abs_tol(getParam<Real>("active_scalar_l_abs_tol")),
     _active_scalar_absolute_tolerance(
         getParam<std::vector<Real>>("active_scalar_absolute_tolerance"))
 {
   // We fetch the systems and their numbers for the momentum equations.
   for (auto system_i : index_range(_momentum_system_names))
   {
     _momentum_system_numbers.push_back(_problem.linearSysNum(_momentum_system_names[system_i]));
     _momentum_systems.push_back(&_problem.getLinearSystem(_momentum_system_numbers[system_i]));
     _systems_to_solve.push_back(_momentum_systems.back());
   }
 
   _systems_to_solve.push_back(&_pressure_system);
 
   if (_has_energy_system)
     _systems_to_solve.push_back(_energy_system);
 
   if (_has_solid_energy_system)
     _systems_to_solve.push_back(_solid_energy_system);
   // and for the turbulence surrogate equations
   if (_has_turbulence_systems)
     for (auto system_i : index_range(_turbulence_system_names))
     {
       _turbulence_system_numbers.push_back(
           _problem.linearSysNum(_turbulence_system_names[system_i]));
       _turbulence_systems.push_back(
           &_problem.getLinearSystem(_turbulence_system_numbers[system_i]));
     }
 
   // and for the passive scalar equations
   if (_has_passive_scalar_systems)
     for (auto system_i : index_range(_passive_scalar_system_names))
     {
       _passive_scalar_system_numbers.push_back(
           _problem.linearSysNum(_passive_scalar_system_names[system_i]));
       _passive_scalar_systems.push_back(
           &_problem.getLinearSystem(_passive_scalar_system_numbers[system_i]));
       _systems_to_solve.push_back(_passive_scalar_systems.back());
     }
 
   // and for the active scalar equations
   if (_has_active_scalar_systems)
     for (auto system_i : index_range(_active_scalar_system_names))
     {
       _active_scalar_system_numbers.push_back(
           _problem.linearSysNum(_active_scalar_system_names[system_i]));
       _active_scalar_systems.push_back(
           &_problem.getLinearSystem(_active_scalar_system_numbers[system_i]));
       _systems_to_solve.push_back(_active_scalar_systems.back());
 
       const auto & active_scalar_petsc_options =
           getParam<MultiMooseEnum>("active_scalar_petsc_options");
       const auto & active_scalar_petsc_pair_options = getParam<MooseEnumItem, std::string>(
           "active_scalar_petsc_options_iname", "active_scalar_petsc_options_value");
       Moose::PetscSupport::addPetscFlagsToPetscOptions(
           active_scalar_petsc_options, "-", *this, _active_scalar_petsc_options);
       Moose::PetscSupport::addPetscPairsToPetscOptions(active_scalar_petsc_pair_options,
                                                        _problem.mesh().dimension(),
                                                        "-",
                                                        *this,
                                                        _active_scalar_petsc_options);
 
       _active_scalar_linear_control.real_valued_data["rel_tol"] =
           getParam<Real>("active_scalar_l_tol");
       _active_scalar_linear_control.real_valued_data["abs_tol"] =
           getParam<Real>("active_scalar_l_abs_tol");
       _active_scalar_linear_control.int_valued_data["max_its"] =
           getParam<unsigned int>("active_scalar_l_max_its");
     }
 
   if (_active_scalar_equation_relaxation.size() != _active_scalar_system_names.size())
     paramError("active_scalar_equation_relaxation",
                "Should be the same size as the number of systems");
 
   // We disable the prefix here for the time being, the segregated solvers use a different approach
   // for setting the petsc parameters
   for (auto & system : _systems_to_solve)
     system->system().prefix_with_name(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
	)

protectedinherited

Definition at line 606 of file SIMPLESolveBase.C.

Referenced by SIMPLESolveBase::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 ( )

inlinevirtualinherited

Check if the user defined time kernels.

Reimplemented in SIMPLESolve, and SIMPLESolveNonlinearAssembly.

Definition at line 61 of file SIMPLESolveBase.h.

61 {}

◆ correctVelocity()

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

protectedvirtual

Computes new velocity field based on computed pressure gradients.

Parameters

subtract_updated_pressure	If we need to subtract the updated pressure gradient from the right hand side of the system
recompute_face_mass_flux	If we want to recompute the face flux too
solver_params	Dummy solver parameter object for the linear solve

Reimplemented in PIMPLESolve.

Definition at line 411 of file LinearAssemblySegregatedSolve.C.

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

 {
   // Compute the coupling fields between the momentum and pressure equations.
   // The first argument makes sure the pressure gradient is staged at the first
   // iteration
   _rc_uo->computeHbyA(subtract_updated_pressure, _print_fields);
 
   // We set the preconditioner/controllable parameters for the pressure equations through
   // petsc options. Linear tolerances will be overridden within the solver.
   Moose::PetscSupport::petscSetOptions(_pressure_petsc_options, solver_params);
 
   // Solve the pressure corrector
   const auto residuals = solvePressureCorrector();
 
   // Compute the face velocity which is used in the advection terms. In certain
   // segregated solver algorithms (like PISO) this is only done on the last iteration.
   if (recompute_face_mass_flux)
     _rc_uo->computeFaceMassFlux();
 
   auto & pressure_current_solution = *(_pressure_system.system().current_local_solution.get());
   auto & pressure_old_solution = *(_pressure_system.solutionPreviousNewton());
 
   // Relax the pressure update for the next momentum predictor
   NS::FV::relaxSolutionUpdate(
       pressure_current_solution, pressure_old_solution, _pressure_variable_relaxation);
 
   // Overwrite old solution
   pressure_old_solution = pressure_current_solution;
   _pressure_system.setSolution(pressure_current_solution);
 
   // We recompute the updated pressure gradient
   _pressure_system.computeGradients();
 
   // Reconstruct the cell velocity as well to accelerate convergence
   _rc_uo->computeCellVelocity();
 
   return residuals;
 }

◆ linkRhieChowUserObject()

void LinearAssemblySegregatedSolve::linkRhieChowUserObject ( )

overridevirtual

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

Implements SIMPLESolveBase.

Definition at line 174 of file LinearAssemblySegregatedSolve.C.

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

 {
   _rc_uo =
       const_cast<RhieChowMassFlux *>(&getUserObject<RhieChowMassFlux>("rhie_chow_user_object"));
   _rc_uo->linkMomentumPressureSystems(
       _momentum_systems, _pressure_system, _momentum_system_numbers);
 
   // Initialize the face velocities in the RC object
   if (!_app.isRecovering())
     _rc_uo->initFaceMassFlux();
   _rc_uo->initCouplingField();
 }

◆ setInnerSolve()

virtual void SIMPLESolveBase::setInnerSolve ( SolveObject & )

inlineoverridevirtualinherited

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 ( )

inherited

Setup pressure pin if there is need for one.

Definition at line 597 of file SIMPLESolveBase.C.

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

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

◆ solve()

bool LinearAssemblySegregatedSolve::solve ( )

overridevirtual

Performs the momentum pressure coupling.

Returns: True if solver is converged.

Implements SolveObject.

Definition at line 540 of file LinearAssemblySegregatedSolve.C.

 {
   // Do not solve if problem is set not to
   if (!_problem.shouldSolve())
     return true;
 
   // Dummy solver parameter file which is needed for switching petsc options
   SolverParams solver_params;
   solver_params._type = Moose::SolveType::ST_LINEAR;
   solver_params._line_search = Moose::LineSearchType::LS_NONE;
 
   // Initialize the SIMPLE iteration counter
   unsigned int simple_iteration_counter = 0;
 
   // Assign residuals to general residual vector
   const unsigned int no_systems = _momentum_systems.size() + 1 + _has_energy_system +
                                   _has_solid_energy_system + _active_scalar_systems.size() +
                                   _turbulence_systems.size();
 
   std::vector<std::pair<unsigned int, Real>> ns_residuals(no_systems, std::make_pair(0, 1.0));
   std::vector<Real> ns_abs_tols(_momentum_systems.size(), _momentum_absolute_tolerance);
   ns_abs_tols.push_back(_pressure_absolute_tolerance);
 
   // Push back energy tolerances
   if (_has_energy_system)
     ns_abs_tols.push_back(_energy_absolute_tolerance);
   if (_has_solid_energy_system)
     ns_abs_tols.push_back(_solid_energy_absolute_tolerance);
   if (_has_active_scalar_systems)
     for (const auto scalar_tol : _active_scalar_absolute_tolerance)
       ns_abs_tols.push_back(scalar_tol);
 
   // Push back turbulence tolerances
   if (_has_turbulence_systems)
     for (const auto turbulence_tol : _turbulence_absolute_tolerance)
       ns_abs_tols.push_back(turbulence_tol);
 
   bool converged = false;
   // Loop until converged or hit the maximum allowed iteration number
   while (simple_iteration_counter < _num_iterations && !converged)
   {
     simple_iteration_counter++;
 
     // We set the preconditioner/controllable parameters through petsc options. Linear
     // tolerances will be overridden within the solver. In case of a segregated momentum
     // solver, we assume that every velocity component uses the same preconditioner
     Moose::PetscSupport::petscSetOptions(_momentum_petsc_options, solver_params);
 
     // Initialize pressure gradients, after this we just reuse the last ones from each
     // iteration
     if (simple_iteration_counter == 1)
       _pressure_system.computeGradients();
 
     _console << "Iteration " << simple_iteration_counter << " Initial residual norms:" << std::endl;
 
     // Solve the momentum predictor step
     auto momentum_residual = solveMomentumPredictor();
     for (const auto system_i : index_range(momentum_residual))
       ns_residuals[system_i] = momentum_residual[system_i];
 
     // Now we correct the velocity, this function depends on the method, it differs for
     // SIMPLE/PIMPLE, this returns the pressure errors
     ns_residuals[momentum_residual.size()] = correctVelocity(true, true, solver_params);
 
     // If we have an energy equation, solve it here.We assume the material properties in the
     // Navier-Stokes equations depend on temperature, therefore we can not solve for temperature
     // outside of the velocity-pressure loop
     if (_has_energy_system)
     {
       // We set the preconditioner/controllable parameters through petsc options. Linear
       // tolerances will be overridden within the solver.
       Moose::PetscSupport::petscSetOptions(_energy_petsc_options, solver_params);
       ns_residuals[momentum_residual.size() + _has_energy_system] =
           solveAdvectedSystem(_energy_sys_number,
                               *_energy_system,
                               _energy_equation_relaxation,
                               _energy_linear_control,
                               _energy_l_abs_tol);
     }
     if (_has_solid_energy_system)
     {
       // We set the preconditioner/controllable parameters through petsc options. Linear
       // tolerances will be overridden within the solver.
       Moose::PetscSupport::petscSetOptions(_solid_energy_petsc_options, solver_params);
       ns_residuals[momentum_residual.size() + _has_solid_energy_system + _has_energy_system] =
           solveSolidEnergy();
     }
 
     // If we have active scalar equations, solve them here in case they depend on temperature
     // or they affect the fluid properties such that they must be solved concurrently with pressure
     // and velocity
     if (_has_active_scalar_systems)
     {
       _problem.execute(EXEC_NONLINEAR);
 
       // We set the preconditioner/controllable parameters through petsc options. Linear
       // tolerances will be overridden within the solver.
       Moose::PetscSupport::petscSetOptions(_active_scalar_petsc_options, solver_params);
       for (const auto i : index_range(_active_scalar_system_names))
         ns_residuals[momentum_residual.size() + 1 + _has_energy_system + _has_solid_energy_system +
                      i] = solveAdvectedSystem(_active_scalar_system_numbers[i],
                                               *_active_scalar_systems[i],
                                               _active_scalar_equation_relaxation[i],
                                               _active_scalar_linear_control,
                                               _active_scalar_l_abs_tol);
     }
 
     // If we have turbulence equations, solve them here.
     // The turbulent viscosity depends on the value of the turbulence surrogate variables
     if (_has_turbulence_systems)
     {
       // We set the preconditioner/controllable parameters through petsc options. Linear
       // tolerances will be overridden within the solver.
       Moose::PetscSupport::petscSetOptions(_turbulence_petsc_options, solver_params);
       for (const auto i : index_range(_turbulence_system_names))
       {
         ns_residuals[momentum_residual.size() + 1 + _has_energy_system + _has_solid_energy_system +
                      _active_scalar_system_names.size() + i] =
             solveAdvectedSystem(_turbulence_system_numbers[i],
                                 *_turbulence_systems[i],
                                 _turbulence_equation_relaxation[i],
                                 _turbulence_linear_control,
                                 _turbulence_l_abs_tol,
                                 _turbulence_field_relaxation[i],
                                 _turbulence_field_min_limit[i]);
       }
     }
 
     _problem.execute(EXEC_NONLINEAR);
 
     converged = NS::FV::converged(ns_residuals, ns_abs_tols);
   }
 
   // If we have passive scalar equations, solve them here. We assume the material properties in the
   // Navier-Stokes equations do not depend on passive scalars, as they are passive, therefore we
   // solve outside of the velocity-pressure loop
   if (_has_passive_scalar_systems && (converged || _continue_on_max_its))
   {
     // The reason why we need more than one iteration is due to the matrix relaxation
     // which can be used to stabilize the equations
     bool passive_scalar_converged = false;
     unsigned int ps_iteration_counter = 0;
 
     _console << "Passive scalar iteration " << ps_iteration_counter
              << " Initial residual norms:" << std::endl;
 
     while (ps_iteration_counter < _num_iterations && !passive_scalar_converged)
     {
       ps_iteration_counter++;
       std::vector<std::pair<unsigned int, Real>> scalar_residuals(
           _passive_scalar_system_names.size(), std::make_pair(0, 1.0));
       std::vector<Real> scalar_abs_tols;
       for (const auto scalar_tol : _passive_scalar_absolute_tolerance)
         scalar_abs_tols.push_back(scalar_tol);
 
       // We set the preconditioner/controllable parameters through petsc options. Linear
       // tolerances will be overridden within the solver.
       Moose::PetscSupport::petscSetOptions(_passive_scalar_petsc_options, solver_params);
       for (const auto i : index_range(_passive_scalar_system_names))
         scalar_residuals[i] = solveAdvectedSystem(_passive_scalar_system_numbers[i],
                                                   *_passive_scalar_systems[i],
                                                   _passive_scalar_equation_relaxation[i],
                                                   _passive_scalar_linear_control,
                                                   _passive_scalar_l_abs_tol);
 
       passive_scalar_converged = NS::FV::converged(scalar_residuals, scalar_abs_tols);
     }
 
     // Both flow and scalars must converge
     converged = passive_scalar_converged && converged;
   }
 
   converged = _continue_on_max_its ? true : converged;
 
   return converged;
 }

◆ 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()`
	)

protected

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

Parameters

system_num	The number of the system which is solved
system	Reference to the system which is solved
relaxation_factor	The relaxation factor for matrix relaxation
solver_config	The solver configuration object for the linear solve
abs_tol	The 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 453 of file LinearAssemblySegregatedSolve.C.

Referenced by solve().

 {
   _problem.setCurrentLinearSystem(system_num);
 
   // We will need some members from the implicit linear system
   LinearImplicitSystem & li_system = libMesh::cast_ref<LinearImplicitSystem &>(system.system());
 
   // We will need the solution, the right hand side and the matrix
   NumericVector<Number> & current_local_solution = *(li_system.current_local_solution);
   NumericVector<Number> & solution = *(li_system.solution);
   SparseMatrix<Number> & mmat = *(li_system.matrix);
   NumericVector<Number> & rhs = *(li_system.rhs);
 
   // We need a vector that stores the (diagonal_relaxed-original_diagonal) vector
   auto diff_diagonal = solution.zero_clone();
 
   // Fetch the linear solver from the system
   PetscLinearSolver<Real> & linear_solver =
       libMesh::cast_ref<PetscLinearSolver<Real> &>(*li_system.get_linear_solver());
 
   _problem.computeLinearSystemSys(li_system, mmat, rhs, true);
 
   // Go and relax the system matrix and the right hand side
   NS::FV::relaxMatrix(mmat, relaxation_factor, *diff_diagonal);
   NS::FV::relaxRightHandSide(rhs, solution, *diff_diagonal);
 
   if (_print_fields)
   {
     _console << system.name() << " system matrix" << std::endl;
     mmat.print();
   }
 
   // We compute the normalization factors based on the fluxes
   Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
 
   // We need the non-preconditioned norm to be consistent with the norm factor
   LibmeshPetscCall(KSPSetNormType(linear_solver.ksp(), KSP_NORM_UNPRECONDITIONED));
 
   // Setting the linear tolerances and maximum iteration counts
   solver_config.real_valued_data["abs_tol"] = absolute_tol * norm_factor;
   linear_solver.set_solver_configuration(solver_config);
 
   // Solve the system and update current local solution
   auto its_res_pair = linear_solver.solve(mmat, mmat, solution, rhs);
   li_system.update();
 
   if (_print_fields)
   {
     _console << " rhs when we solve " << system.name() << std::endl;
     rhs.print();
     _console << system.name() << " solution " << std::endl;
     solution.print();
     _console << " Norm factor " << norm_factor << std::endl;
   }
 
   // Limiting scalar solution
   if (min_value_limiter != std::numeric_limits<Real>::min())
     NS::FV::limitSolutionUpdate(current_local_solution, min_value_limiter);
 
   // Relax the field update for the next momentum predictor
   if (field_relaxation != 1.0)
   {
     auto & old_local_solution = *(system.solutionPreviousNewton());
     NS::FV::relaxSolutionUpdate(current_local_solution, old_local_solution, field_relaxation);
 
     // Update old solution, only needed if relaxing the field
     old_local_solution = current_local_solution;
   }
 
   system.setSolution(current_local_solution);
 
   const auto residuals =
       std::make_pair(its_res_pair.first, linear_solver.get_initial_residual() / norm_factor);
 
   _console << " Advected system: " << system.name() << " " << COLOR_GREEN << residuals.second
            << COLOR_DEFAULT << " Linear its: " << residuals.first << std::endl;
 
   return residuals;
 }

◆ solveMomentumPredictor()

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

overrideprotectedvirtual

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 188 of file LinearAssemblySegregatedSolve.C.

Referenced by solve().

 {
   // Temporary storage for the (flux-normalized) residuals from
   // different momentum components
   std::vector<std::pair<unsigned int, Real>> its_normalized_residuals;
 
   LinearImplicitSystem & momentum_system_0 =
       libMesh::cast_ref<LinearImplicitSystem &>(_momentum_systems[0]->system());
 
   PetscLinearSolver<Real> & momentum_solver =
       libMesh::cast_ref<PetscLinearSolver<Real> &>(*momentum_system_0.get_linear_solver());
 
   // Solve the momentum equations.
   // TO DO: These equations are VERY similar. If we can store the differences (things coming from
   // BCs for example) separately, it is enough to construct one matrix.
   for (const auto system_i : index_range(_momentum_systems))
   {
     _problem.setCurrentLinearSystem(_momentum_system_numbers[system_i]);
 
     // We will need the right hand side and the solution of the next component
     LinearImplicitSystem & momentum_system =
         libMesh::cast_ref<LinearImplicitSystem &>(_momentum_systems[system_i]->system());
 
     NumericVector<Number> & solution = *(momentum_system.solution);
     NumericVector<Number> & rhs = *(momentum_system.rhs);
     SparseMatrix<Number> & mmat = *(momentum_system.matrix);
 
     auto diff_diagonal = solution.zero_clone();
 
     // We assemble the matrix and the right hand side
     _problem.computeLinearSystemSys(momentum_system, mmat, rhs, /*compute_grads*/ true);
 
     // Still need to relax the right hand side with the same vector
     NS::FV::relaxMatrix(mmat, _momentum_equation_relaxation, *diff_diagonal);
     NS::FV::relaxRightHandSide(rhs, solution, *diff_diagonal);
 
     // The normalization factor depends on the right hand side so we need to recompute it for this
     // component
     Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
 
     // Very important, for deciding the convergence, we need the unpreconditioned
     // norms in the linear solve
     LibmeshPetscCall(KSPSetNormType(momentum_solver.ksp(), KSP_NORM_UNPRECONDITIONED));
     // Solve this component. We don't update the ghosted solution yet, that will come at the end
     // of the corrector step. Also setting the linear tolerances and maximum iteration counts.
     _momentum_linear_control.real_valued_data["abs_tol"] = _momentum_l_abs_tol * norm_factor;
     momentum_solver.set_solver_configuration(_momentum_linear_control);
 
     // We solve the equation
     auto its_resid_pair = momentum_solver.solve(mmat, mmat, solution, rhs);
     momentum_system.update();
 
     // We will reuse the preconditioner for every momentum system
     if (system_i == 0)
       momentum_solver.reuse_preconditioner(true);
 
     // Save the normalized residual
     its_normalized_residuals.push_back(
         std::make_pair(its_resid_pair.first, momentum_solver.get_initial_residual() / norm_factor));
 
     if (_print_fields)
     {
       _console << " solution after solve " << std::endl;
       solution.print();
       _console << " matrix when we solve " << std::endl;
       mmat.print();
       _console << " rhs when we solve " << std::endl;
       rhs.print();
       _console << " velocity solution component " << system_i << std::endl;
       solution.print();
       _console << "Norm factor " << norm_factor << std::endl;
       _console << Moose::stringify(momentum_solver.get_initial_residual()) << std::endl;
     }
 
     // Printing residuals
     _console << " Momentum equation:"
              << (_momentum_systems.size() > 1
                      ? std::string(" Component ") + std::to_string(system_i + 1) + std::string(" ")
                      : std::string(" "))
              << COLOR_GREEN << its_normalized_residuals[system_i].second << COLOR_DEFAULT
              << " Linear its: " << its_normalized_residuals[system_i].first << std::endl;
   }
 
   for (const auto system_i : index_range(_momentum_systems))
   {
     LinearImplicitSystem & momentum_system =
         libMesh::cast_ref<LinearImplicitSystem &>(_momentum_systems[system_i]->system());
     _momentum_systems[system_i]->setSolution(*(momentum_system.current_local_solution));
     _momentum_systems[system_i]->copyPreviousNonlinearSolutions();
   }
 
   // We reset this to ensure the preconditioner is recomputed new time we go to the momentum
   // predictor
   momentum_solver.reuse_preconditioner(false);
 
   return its_normalized_residuals;
 }

◆ solvePressureCorrector()

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

overrideprotectedvirtual

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 287 of file LinearAssemblySegregatedSolve.C.

Referenced by correctVelocity().

 {
   _problem.setCurrentLinearSystem(_pressure_sys_number);
 
   // We will need some members from the linear system
   LinearImplicitSystem & pressure_system =
       libMesh::cast_ref<LinearImplicitSystem &>(_pressure_system.system());
 
   // We will need the solution, the right hand side and the matrix
   NumericVector<Number> & current_local_solution = *(pressure_system.current_local_solution);
   NumericVector<Number> & solution = *(pressure_system.solution);
   SparseMatrix<Number> & mmat = *(pressure_system.matrix);
   NumericVector<Number> & rhs = *(pressure_system.rhs);
 
   // Fetch the linear solver from the system
   PetscLinearSolver<Real> & pressure_solver =
       libMesh::cast_ref<PetscLinearSolver<Real> &>(*pressure_system.get_linear_solver());
 
   _problem.computeLinearSystemSys(pressure_system, mmat, rhs, false);
 
   if (_print_fields)
   {
     _console << "Pressure matrix" << std::endl;
     mmat.print();
   }
 
   // We compute the normalization factors based on the fluxes
   Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
 
   // We need the non-preconditioned norm to be consistent with the norm factor
   LibmeshPetscCall(KSPSetNormType(pressure_solver.ksp(), KSP_NORM_UNPRECONDITIONED));
 
   // Setting the linear tolerances and maximum iteration counts
   _pressure_linear_control.real_valued_data["abs_tol"] = _pressure_l_abs_tol * norm_factor;
   pressure_solver.set_solver_configuration(_pressure_linear_control);
 
   if (_pin_pressure)
     NS::FV::constrainSystem(mmat, rhs, _pressure_pin_value, _pressure_pin_dof);
   pressure_system.update();
 
   auto its_res_pair = pressure_solver.solve(mmat, mmat, solution, rhs);
   pressure_system.update();
 
   if (_print_fields)
   {
     _console << " rhs when we solve pressure " << std::endl;
     rhs.print();
     _console << " Pressure " << std::endl;
     solution.print();
     _console << "Norm factor " << norm_factor << std::endl;
   }
 
   _pressure_system.setSolution(current_local_solution);
 
   const auto residuals =
       std::make_pair(its_res_pair.first, pressure_solver.get_initial_residual() / norm_factor);
 
   _console << " Pressure equation: " << COLOR_GREEN << residuals.second << COLOR_DEFAULT
            << " Linear its: " << residuals.first << std::endl;
 
   return residuals;
 }

◆ solveSolidEnergy()

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

protected

Solve an equation which contains the solid energy conservation.

Definition at line 351 of file LinearAssemblySegregatedSolve.C.

Referenced by solve().

 {
   _problem.setCurrentLinearSystem(_solid_energy_sys_number);
 
   // We will need some members from the linear system
   LinearImplicitSystem & system =
       libMesh::cast_ref<LinearImplicitSystem &>(_solid_energy_system->system());
 
   // We will need the solution, the right hand side and the matrix
   NumericVector<Number> & current_local_solution = *(system.current_local_solution);
   NumericVector<Number> & solution = *(system.solution);
   SparseMatrix<Number> & mmat = *(system.matrix);
   NumericVector<Number> & rhs = *(system.rhs);
 
   // Fetch the linear solver from the system
   PetscLinearSolver<Real> & solver =
       libMesh::cast_ref<PetscLinearSolver<Real> &>(*system.get_linear_solver());
 
   _problem.computeLinearSystemSys(system, mmat, rhs, false);
 
   if (_print_fields)
   {
     _console << "Solid energy matrix" << std::endl;
     mmat.print();
   }
 
   // We compute the normalization factors based on the fluxes
   Real norm_factor = NS::FV::computeNormalizationFactor(solution, mmat, rhs);
 
   // We need the non-preconditioned norm to be consistent with the norm factor
   LibmeshPetscCall(KSPSetNormType(solver.ksp(), KSP_NORM_UNPRECONDITIONED));
 
   // Setting the linear tolerances and maximum iteration counts
   _solid_energy_linear_control.real_valued_data["abs_tol"] = _solid_energy_l_abs_tol * norm_factor;
   solver.set_solver_configuration(_solid_energy_linear_control);
 
   auto its_res_pair = solver.solve(mmat, mmat, solution, rhs);
   system.update();
 
   if (_print_fields)
   {
     _console << " rhs when we solve solid energy " << std::endl;
     rhs.print();
     _console << " Solid energy " << std::endl;
     solution.print();
     _console << "Norm factor " << norm_factor << std::endl;
   }
 
   _solid_energy_system->setSolution(current_local_solution);
 
   const auto residuals =
       std::make_pair(its_res_pair.first, solver.get_initial_residual() / norm_factor);
 
   _console << " Solid energy equation: " << COLOR_GREEN << residuals.second << COLOR_DEFAULT
            << " Linear its: " << residuals.first << std::endl;
 
   return residuals;
 }

◆ systemsToSolve()

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

inline

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

Definition at line 38 of file LinearAssemblySegregatedSolve.h.

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

38 { 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:112

◆ validParams()

InputParameters LinearAssemblySegregatedSolve::validParams ( )

static

Definition at line 18 of file LinearAssemblySegregatedSolve.C.

Referenced by SIMPLESolve::validParams(), and PIMPLESolve::validParams().

 {
   InputParameters params = SIMPLESolveBase::validParams();
 
   params.addParam<std::vector<SolverSystemName>>(
       "active_scalar_systems", {}, "The solver system for each active scalar advection equation.");
 
   /*
    * Parameters to control the solution of each scalar advection system
    */
   params.addParam<std::vector<Real>>("active_scalar_equation_relaxation",
                                      std::vector<Real>(),
                                      "The relaxation which should be used for the active scalar "
                                      "equations. (=1 for no relaxation, "
                                      "diagonal dominance will still be enforced)");
 
   params.addParam<MultiMooseEnum>("active_scalar_petsc_options",
                                   Moose::PetscSupport::getCommonPetscFlags(),
                                   "Singleton PETSc options for the active scalar equation(s)");
   params.addParam<MultiMooseEnum>(
       "active_scalar_petsc_options_iname",
       Moose::PetscSupport::getCommonPetscKeys(),
       "Names of PETSc name/value pairs for the active scalar equation(s)");
   params.addParam<std::vector<std::string>>(
       "active_scalar_petsc_options_value",
       "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
       "active scalar equation(s)");
   params.addParam<std::vector<Real>>(
       "active_scalar_absolute_tolerance",
       std::vector<Real>(),
       "The absolute tolerance(s) on the normalized residual(s) of the active scalar equation(s).");
   params.addRangeCheckedParam<Real>("active_scalar_l_tol",
                                     1e-5,
                                     "0.0<=active_scalar_l_tol & active_scalar_l_tol<1.0",
                                     "The relative tolerance on the normalized residual in the "
                                     "linear solver of the active scalar equation(s).");
   params.addRangeCheckedParam<Real>("active_scalar_l_abs_tol",
                                     1e-10,
                                     "0.0<active_scalar_l_abs_tol",
                                     "The absolute tolerance on the normalized residual in the "
                                     "linear solver of the active scalar equation(s).");
   params.addParam<unsigned int>(
       "active_scalar_l_max_its",
       10000,
       "The maximum allowed iterations in the linear solver of the turbulence equation.");
 
   params.addParamNamesToGroup(
       "active_scalar_systems active_scalar_equation_relaxation active_scalar_petsc_options "
       "active_scalar_petsc_options_iname "
       "active_scalar_petsc_options_value active_scalar_petsc_options_value "
       "active_scalar_absolute_tolerance "
       "active_scalar_l_tol active_scalar_l_abs_tol active_scalar_l_max_its",
       "Active Scalars Equations");
 
   return params;
 }

Member Data Documentation

◆ _active_scalar_absolute_tolerance

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

protected

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

Definition at line 139 of file LinearAssemblySegregatedSolve.h.

Referenced by solve().

◆ _active_scalar_equation_relaxation

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

protected

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

Definition at line 126 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve(), and solve().

◆ _active_scalar_l_abs_tol

const Real LinearAssemblySegregatedSolve::_active_scalar_l_abs_tol

protected

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 136 of file LinearAssemblySegregatedSolve.h.

Referenced by solve().

◆ _active_scalar_linear_control

SIMPLESolverConfiguration LinearAssemblySegregatedSolve::_active_scalar_linear_control

protected

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

Definition at line 132 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve(), and solve().

◆ _active_scalar_petsc_options

Moose::PetscSupport::PetscOptions LinearAssemblySegregatedSolve::_active_scalar_petsc_options

protected

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

Definition at line 129 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve(), and solve().

◆ _active_scalar_system_names

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

protected

The names of the active scalar systems.

Definition at line 117 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve(), and solve().

◆ _active_scalar_system_numbers

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

protected

Definition at line 123 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve(), and solve().

◆ _active_scalar_systems

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

protected

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

Definition at line 103 of file LinearAssemblySegregatedSolve.h.

Referenced by SIMPLESolve::checkIntegrity(), LinearAssemblySegregatedSolve(), and 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 235 of file SIMPLESolveBase.h.

Referenced by solve(), and SIMPLESolveNonlinearAssembly::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 220 of file SIMPLESolveBase.h.

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

◆ _energy_sys_number

const unsigned int LinearAssemblySegregatedSolve::_energy_sys_number

protected

The number of the system corresponding to the energy equation.

Definition at line 88 of file LinearAssemblySegregatedSolve.h.

Referenced by solve().

◆ _energy_system

LinearSystem* LinearAssemblySegregatedSolve::_energy_system

protected

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

Definition at line 91 of file LinearAssemblySegregatedSolve.h.

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

◆ _has_active_scalar_systems

const bool LinearAssemblySegregatedSolve::_has_active_scalar_systems

protected

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

Definition at line 120 of file LinearAssemblySegregatedSolve.h.

Referenced by SIMPLESolve::checkIntegrity(), LinearAssemblySegregatedSolve(), and 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 SIMPLESolve::checkIntegrity(), SIMPLESolveNonlinearAssembly::checkIntegrity(), LinearAssemblySegregatedSolve(), SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly(), SIMPLESolveNonlinearAssembly::solve(), and 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 SIMPLESolve::checkIntegrity(), SIMPLESolveNonlinearAssembly::checkIntegrity(), LinearAssemblySegregatedSolve(), SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::SIMPLESolveNonlinearAssembly(), SIMPLESolveNonlinearAssembly::solve(), and 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(), SIMPLESolveBase::SIMPLESolveBase(), SIMPLESolveNonlinearAssembly::solve(), and 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 187 of file SIMPLESolveBase.h.

Referenced by SIMPLESolve::checkIntegrity(), LinearAssemblySegregatedSolve(), SIMPLESolveBase::SIMPLESolveBase(), and 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 214 of file SIMPLESolveBase.h.

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

◆ _momentum_system_numbers

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

protected

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

Definition at line 76 of file LinearAssemblySegregatedSolve.h.

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

◆ _momentum_systems

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

protected

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

Definition at line 79 of file LinearAssemblySegregatedSolve.h.

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

◆ _num_iterations

const unsigned int SIMPLESolveBase::_num_iterations

protectedinherited

The maximum number of momentum-pressure iterations.

Definition at line 232 of file SIMPLESolveBase.h.

Referenced by solve(), and SIMPLESolveNonlinearAssembly::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 226 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_systems

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

protected

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

Definition at line 100 of file LinearAssemblySegregatedSolve.h.

Referenced by SIMPLESolve::checkIntegrity(), LinearAssemblySegregatedSolve(), and 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 solvePressureCorrector().

◆ _pressure_absolute_tolerance

const Real SIMPLESolveBase::_pressure_absolute_tolerance

protectedinherited

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

Definition at line 217 of file SIMPLESolveBase.h.

Referenced by solve(), 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 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 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 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 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 solvePressureCorrector().

◆ _pressure_sys_number

const unsigned int LinearAssemblySegregatedSolve::_pressure_sys_number

protected

The number of the system corresponding to the pressure equation.

Definition at line 82 of file LinearAssemblySegregatedSolve.h.

Referenced by solvePressureCorrector().

◆ _pressure_system

LinearSystem& LinearAssemblySegregatedSolve::_pressure_system

protected

Reference to the nonlinear system corresponding to the pressure equation.

Definition at line 85 of file LinearAssemblySegregatedSolve.h.

Referenced by SIMPLESolve::checkIntegrity(), correctVelocity(), LinearAssemblySegregatedSolve(), linkRhieChowUserObject(), solve(), and 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 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 240 of file SIMPLESolveBase.h.

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

◆ _rc_uo

RhieChowMassFlux* LinearAssemblySegregatedSolve::_rc_uo

protected

Pointer to the segregated RhieChow interpolation object.

Definition at line 109 of file LinearAssemblySegregatedSolve.h.

Referenced by correctVelocity(), and linkRhieChowUserObject().

◆ _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 223 of file SIMPLESolveBase.h.

Referenced by solve(), 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 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(), 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 solve().

◆ _solid_energy_sys_number

const unsigned int LinearAssemblySegregatedSolve::_solid_energy_sys_number

protected

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

Definition at line 94 of file LinearAssemblySegregatedSolve.h.

Referenced by solveSolidEnergy().

◆ _solid_energy_system

LinearSystem* LinearAssemblySegregatedSolve::_solid_energy_system

protected

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

Definition at line 97 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve(), and solveSolidEnergy().

◆ _systems_to_solve

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

protected

Shortcut to every linear system that we solve for here.

Definition at line 112 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve(), and 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 229 of file SIMPLESolveBase.h.

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

◆ _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 193 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and 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 199 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and 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 196 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and 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 209 of file SIMPLESolveBase.h.

Referenced by solve().

◆ _turbulence_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_turbulence_linear_control

protectedinherited

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

Definition at line 205 of file SIMPLESolveBase.h.

Referenced by SIMPLESolveBase::SIMPLESolveBase(), and 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 202 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_names

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

protectedinherited

The names of the turbulence systems.

Definition at line 184 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_numbers

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

protectedinherited

Definition at line 190 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve(), and solve().

◆ _turbulence_systems

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

protected

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

Definition at line 106 of file LinearAssemblySegregatedSolve.h.

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

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

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ LinearAssemblySegregatedSolve()

Member Function Documentation

◆ checkDependentParameterError()

◆ checkIntegrity()

◆ correctVelocity()

◆ linkRhieChowUserObject()

◆ setInnerSolve()

◆ setupPressurePin()

◆ solve()

◆ solveAdvectedSystem()

◆ solveMomentumPredictor()

◆ solvePressureCorrector()

◆ solveSolidEnergy()

◆ systemsToSolve()

◆ validParams()

Member Data Documentation

◆ _active_scalar_absolute_tolerance

◆ _active_scalar_equation_relaxation

◆ _active_scalar_l_abs_tol

◆ _active_scalar_linear_control

◆ _active_scalar_petsc_options

◆ _active_scalar_system_names

◆ _active_scalar_system_numbers

◆ _active_scalar_systems

◆ _continue_on_max_its

◆ _energy_absolute_tolerance

◆ _energy_equation_relaxation

◆ _energy_l_abs_tol

◆ _energy_linear_control

◆ _energy_petsc_options

◆ _energy_sys_number

◆ _energy_system

◆ _has_active_scalar_systems

◆ _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

◆ _momentum_system_numbers

◆ _momentum_systems

◆ _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

◆ _passive_scalar_systems

◆ _pin_pressure

◆ _pressure_absolute_tolerance

◆ _pressure_l_abs_tol

◆ _pressure_linear_control

◆ _pressure_petsc_options

◆ _pressure_pin_dof

◆ _pressure_pin_value

◆ _pressure_sys_number

◆ _pressure_system

◆ _pressure_system_name

◆ _pressure_variable_relaxation

◆ _print_fields

◆ _rc_uo

◆ _solid_energy_absolute_tolerance

◆ _solid_energy_l_abs_tol

◆ _solid_energy_linear_control

◆ _solid_energy_petsc_options

◆ _solid_energy_sys_number