PIMPLE-based (PISO + SIMPLE) for transient solution object with linear FV system assembly. More...

#include <PIMPLESolve.h>

Inheritance diagram for PIMPLESolve:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PIMPLESolve (Executioner &ex)

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

virtual void	initialSetup () override

virtual bool	solve () override
	Performs the momentum pressure coupling. More...

const std::vector< LinearSystem * >	systemsToSolve () const
	Return pointers to the systems which are solved for within this object. More...

virtual void	setInnerSolve (SolveObject &) override

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

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

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

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

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	haveParameter (const std::string &name) const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

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

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

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

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

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

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

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

UserObjectName	getUserObjectName (const std::string &param_name) const

const T &	getUserObject (const std::string &param_name, bool is_dependency=true) const

const T &	getUserObjectByName (const UserObjectName &object_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBase (const std::string &param_name, bool is_dependency=true) const

const UserObjectBase &	getUserObjectBaseByName (const UserObjectName &object_name, bool is_dependency=true) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObject (const std::string &param_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

bool	hasUserObjectByName (const UserObjectName &object_name) const

Static Public Member Functions
static InputParameters	validParams ()

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

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Member Functions
virtual std::pair< unsigned int, Real >	correctVelocity (const bool subtract_updated_pressure, const bool recompute_face_mass_flux, const SolverParams &solver_params) override
	Computes new velocity field based on computed pressure gradients. More...

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

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

std::pair< unsigned int, Real >	solveAdvectedSystem (const unsigned int system_num, LinearSystem &system, const Real relaxation_factor, libMesh::SolverConfiguration &solver_config, const Real abs_tol, const Real field_relaxation=1.0, const Real min_value_limiter=std::numeric_limits< Real >::min())
	Solve an equation which contains an advection term that depends on the solution of the segregated Navier-Stokes equations. More...

ResidualStorage	setupResidualStorage () const
	Build residual/tolerance vectors and associated indices for all enabled systems. More...

std::pair< unsigned int, Real >	solveSolidEnergy ()
	Solve an equation which contains the solid energy conservation. More...

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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

virtual void	addUserObjectDependencyHelper (const UserObjectBase &) const

Protected Attributes
const unsigned int	_num_piso_iterations
	Number of H(u) and u iterations with fixed face flux. More...

std::vector< unsigned int >	_momentum_system_numbers
	The number(s) of the system(s) corresponding to the momentum equation(s) More...

std::vector< LinearSystem * >	_momentum_systems
	Pointer(s) to the system(s) corresponding to the momentum equation(s) More...

const unsigned int	_pressure_sys_number
	The number of the system corresponding to the pressure equation. More...

LinearSystem &	_pressure_system
	Reference to the linear system corresponding to the pressure equation. More...

const unsigned int	_energy_sys_number
	The number of the system corresponding to the energy equation. More...

LinearSystem *	_energy_system
	Pointer to the linear system corresponding to the fluid energy equation. More...

const unsigned int	_solid_energy_sys_number
	The number of the system corresponding to the solid energy equation. More...

LinearSystem *	_solid_energy_system
	Pointer to the linear system corresponding to the solid energy equation. More...

std::vector< LinearSystem * >	_passive_scalar_systems
	Pointer(s) to the system(s) corresponding to the passive scalar equation(s) More...

std::vector< LinearSystem * >	_pm_radiation_systems
	Pointer(s) to the system(s) corresponding to the participting media radiation equation(s) More...

std::vector< LinearSystem * >	_active_scalar_systems
	Pointer(s) to the system(s) corresponding to the active scalar equation(s) More...

std::vector< LinearSystem * >	_turbulence_systems
	Pointer(s) to the system(s) corresponding to the turbulence equation(s) More...

RhieChowMassFlux *	_rc_uo
	Pointer to the segregated RhieChow interpolation object. More...

std::vector< LinearSystem * >	_systems_to_solve
	Shortcut to every linear system that we solve for here. More...

const bool	_should_solve_momentum
	Flags controlling which systems are actively solved (can be used with restart to freeze flow) More...

const bool	_should_solve_pressure

const bool	_should_solve_energy

const bool	_should_solve_solid_energy

const bool	_should_solve_turbulence

const bool	_should_solve_passive_scalars

const bool	_should_solve_active_scalars

const bool	_should_solve_pm_radiation

const std::vector< SolverSystemName > &	_active_scalar_system_names
	The names of the active scalar systems. More...

const bool	_has_active_scalar_systems
	Boolean for easy check if a active scalar systems shall be solved or not. More...

std::vector< unsigned int >	_active_scalar_system_numbers

const std::vector< Real >	_active_scalar_equation_relaxation
	The user-defined relaxation parameter(s) for the active scalar equation(s) More...

Moose::PetscSupport::PetscOptions	_active_scalar_petsc_options
	Options which hold the petsc settings for the active scalar equation(s) More...

SIMPLESolverConfiguration	_active_scalar_linear_control
	Options for the linear solver of the active scalar equation(s) More...

const Real	_active_scalar_l_abs_tol
	Absolute linear tolerance for the active scalar equation(s). More...

const std::vector< Real >	_active_scalar_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence in active scalars. More...

NS::FV::CHTHandler	_cht
	******************** Conjugate heat transfer variables ************ // More...

const std::vector< SolverSystemName > &	_momentum_system_names
	The names of the momentum systems. More...

SIMPLESolverConfiguration	_momentum_linear_control
	Options for the linear solver of the momentum equation. More...

const Real	_momentum_l_abs_tol
	Absolute linear tolerance for the momentum equation(s). More...

Moose::PetscSupport::PetscOptions	_momentum_petsc_options
	Options which hold the petsc settings for the momentum equation. More...

const Real	_momentum_equation_relaxation
	The user-defined relaxation parameter for the momentum equation. More...

const SolverSystemName &	_pressure_system_name
	The name of the pressure system. More...

SIMPLESolverConfiguration	_pressure_linear_control
	Options for the linear solver of the pressure equation. More...

const Real	_pressure_l_abs_tol
	Absolute linear tolerance for the pressure equation. More...

Moose::PetscSupport::PetscOptions	_pressure_petsc_options
	Options which hold the petsc settings for the pressure equation. More...

const Real	_pressure_variable_relaxation
	The user-defined relaxation parameter for the pressure variable. More...

const bool	_pin_pressure
	If the pressure needs to be pinned. More...

const Real	_pressure_pin_value
	The value we want to enforce for pressure. More...

dof_id_type	_pressure_pin_dof
	The dof ID where the pressure needs to be pinned. More...

const bool	_has_energy_system
	Boolean for easy check if a fluid energy system shall be solved or not. More...

const Real	_energy_equation_relaxation
	The user-defined relaxation parameter for the energy equation. More...

Moose::PetscSupport::PetscOptions	_energy_petsc_options
	Options which hold the petsc settings for the fluid energy equation. More...

SIMPLESolverConfiguration	_energy_linear_control
	Options for the linear solver of the energy equation. More...

const Real	_energy_l_abs_tol
	Absolute linear tolerance for the energy equations. More...

const bool	_has_solid_energy_system
	Boolean for easy check if a solid energy system shall be solved or not. More...

Moose::PetscSupport::PetscOptions	_solid_energy_petsc_options
	Options which hold the petsc settings for the fluid energy equation. More...

SIMPLESolverConfiguration	_solid_energy_linear_control
	Options for the linear solver of the energy equation. More...

const Real	_solid_energy_l_abs_tol
	Absolute linear tolerance for the energy equations. More...

const std::vector< SolverSystemName > &	_passive_scalar_system_names
	The names of the passive scalar systems. More...

const bool	_has_passive_scalar_systems
	Boolean for easy check if a passive scalar systems shall be solved or not. More...

std::vector< unsigned int >	_passive_scalar_system_numbers

const std::vector< Real >	_passive_scalar_equation_relaxation
	The user-defined relaxation parameter(s) for the passive scalar equation(s) More...

Moose::PetscSupport::PetscOptions	_passive_scalar_petsc_options
	Options which hold the petsc settings for the passive scalar equation(s) More...

SIMPLESolverConfiguration	_passive_scalar_linear_control
	Options for the linear solver of the passive scalar equation(s) More...

const Real	_passive_scalar_l_abs_tol
	Absolute linear tolerance for the passive scalar equation(s). More...

const std::vector< SolverSystemName > &	_pm_radiation_system_names
	The names of the participating media radiation systems. More...

const bool	_has_pm_radiation_systems
	Boolean for easy check if participating media radiation systems shall be solved or not. More...

std::vector< unsigned int >	_pm_radiation_system_numbers

const std::vector< Real >	_pm_radiation_equation_relaxation
	The user-defined relaxation parameter(s) for the participating media radiation equation(s) More...

Moose::PetscSupport::PetscOptions	_pm_radiation_petsc_options
	Options which hold the petsc settings for the participating media radiation equation(s) More...

SIMPLESolverConfiguration	_pm_radiation_linear_control
	Options for the linear solver of the participating media radiation equation(s) More...

const Real	_pm_radiation_l_abs_tol
	Absolute linear tolerance for the participating media radiation equation(s). More...

const std::vector< SolverSystemName > &	_turbulence_system_names
	The names of the turbulence systems. More...

const bool	_has_turbulence_systems
	Boolean for easy check if a turbulence scalar systems shall be solved or not. More...

std::vector< unsigned int >	_turbulence_system_numbers

const std::vector< Real >	_turbulence_equation_relaxation
	The user-defined relaxation parameter(s) for the turbulence equation(s) More...

std::vector< Real >	_turbulence_field_relaxation
	The user-defined relaxation parameter(s) for the turbulence field(s) More...

std::vector< Real >	_turbulence_field_min_limit
	The user-defined lower limit for turbulent quantities e.g. k, eps/omega, etc.. More...

Moose::PetscSupport::PetscOptions	_turbulence_petsc_options
	Options which hold the petsc settings for the turbulence equation(s) More...

SIMPLESolverConfiguration	_turbulence_linear_control
	Options for the linear solver of the turbulence equation(s) More...

const Real	_turbulence_l_abs_tol
	Absolute linear tolerance for the turbulence equation(s). More...

const Real	_momentum_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence in momentum. More...

const Real	_pressure_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence in pressure. More...

const Real	_energy_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence in energy. More...

const Real	_solid_energy_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence in solid energy. More...

const std::vector< Real >	_passive_scalar_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence in passive scalars. More...

const std::vector< Real >	_pm_radiation_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence in participating media radiation. More...

const std::vector< Real >	_turbulence_absolute_tolerance
	The user-defined absolute tolerance for determining the convergence turbulence variables. More...

const unsigned int	_num_iterations
	The maximum number of momentum-pressure iterations. More...

const bool	_continue_on_max_its
	If solve should continue if maximum number of iterations is hit. More...

const bool	_print_fields
	Debug parameter which allows printing the coupling and solution vectors/matrices. More...

Executioner &	_executioner

FEProblemBase &	_problem

DisplacedProblem *	_displaced_problem

MooseMesh &	_mesh

MooseMesh *	_displaced_mesh

SystemBase &	_solver_sys

AuxiliarySystem &	_aux

SolveObject *	_inner_solve

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Detailed Description

PIMPLE-based (PISO + SIMPLE) for transient solution object with linear FV system assembly.

A detailed discussion of the algorithm is available in { greenshieldsweller2022, title = "Notes on Computational Fluid Dynamics: General Principles", author = "Greenshields, Christopher and Weller, Henry", year = 2022, publisher = "CFD Direct Ltd", address = "Reading, UK" } This will be the basis for the SIMPLE algorithm as well, we just set the PISO iterations to 0.

Definition at line 31 of file PIMPLESolve.h.

Constructor & Destructor Documentation

◆ PIMPLESolve()

PIMPLESolve::PIMPLESolve ( Executioner & ex )

Definition at line 29 of file PIMPLESolve.C.

   : LinearAssemblySegregatedSolve(ex),
     _num_piso_iterations(getParam<unsigned int>("num_piso_iterations"))
 {
 }

Member Function Documentation

◆ checkDependentParameterError()

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

protectedinherited

Definition at line 707 of file SIMPLESolveBase.C.

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

 {
   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 > PIMPLESolve::correctVelocity	(	const bool	subtract_updated_pressure,
		const bool	recompute_face_mass_flux,
		const SolverParams &	solver_params
	)

overrideprotectedvirtual

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 from LinearAssemblySegregatedSolve.

Definition at line 36 of file PIMPLESolve.C.

 {
   std::pair<unsigned int, Real> residual;
   unsigned int piso_iteration_counter = 0;
   while (piso_iteration_counter <= _num_piso_iterations)
   {
     residual = LinearAssemblySegregatedSolve::correctVelocity(
         piso_iteration_counter == 0, piso_iteration_counter == _num_piso_iterations, solver_params);
     piso_iteration_counter++;
   }
 
   return residual;
 }

◆ initialSetup()

void LinearAssemblySegregatedSolve::initialSetup ( )

overridevirtualinherited

Reimplemented from SolveObject.

Definition at line 372 of file LinearAssemblySegregatedSolve.C.

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

 {
   if (_cht.enabled())
   {
     _cht.deduceCHTBoundaryCoupling();
     _cht.setupConjugateHeatTransferContainers();
   }
 }

◆ linkRhieChowUserObject()

void LinearAssemblySegregatedSolve::linkRhieChowUserObject ( )

overridevirtualinherited

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

Implements SIMPLESolveBase.

Definition at line 258 of file LinearAssemblySegregatedSolve.C.

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

 {
   if (!_should_solve_momentum)
     return;
 
   _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 698 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"));
 }

◆ setupResidualStorage()

LinearAssemblySegregatedSolve::ResidualStorage LinearAssemblySegregatedSolve::setupResidualStorage ( ) const

protectedinherited

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

Definition at line 855 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   ResidualStorage storage;
 
   // Residual store: position in this vector defines the ordering used by NS::FV::converged()
   // Each entry holds (linear its, normalized residual) for one system
   if (_should_solve_momentum)
     for ([[maybe_unused]] const auto system_i : index_range(_momentum_systems))
     {
       storage.momentum_indices.push_back(storage.ns_residuals.size());
       storage.ns_residuals.push_back(std::make_pair(0, 1.0));
       storage.ns_abs_tols.push_back(_momentum_absolute_tolerance);
     }
 
   if (_should_solve_pressure)
   {
     storage.pressure_index = storage.ns_residuals.size();
     storage.ns_residuals.push_back(std::make_pair(0, 1.0));
     storage.ns_abs_tols.push_back(_pressure_absolute_tolerance);
   }
 
   if (_has_energy_system && _should_solve_energy)
   {
     storage.energy_index = storage.ns_residuals.size();
     storage.ns_residuals.push_back(std::make_pair(0, 1.0));
     storage.ns_abs_tols.push_back(_energy_absolute_tolerance);
   }
 
   if (_has_solid_energy_system && _should_solve_solid_energy)
   {
     storage.solid_energy_index = storage.ns_residuals.size();
     storage.ns_residuals.push_back(std::make_pair(0, 1.0));
     storage.ns_abs_tols.push_back(_solid_energy_absolute_tolerance);
   }
 
   if (_has_active_scalar_systems && _should_solve_active_scalars)
     for (const auto i : index_range(_active_scalar_system_names))
     {
       storage.active_scalar_indices.push_back(storage.ns_residuals.size());
       storage.ns_residuals.push_back(std::make_pair(0, 1.0));
       storage.ns_abs_tols.push_back(_active_scalar_absolute_tolerance[i]);
     }
 
   if (_has_turbulence_systems && _should_solve_turbulence)
     for (const auto i : index_range(_turbulence_system_names))
     {
       storage.turbulence_indices.push_back(storage.ns_residuals.size());
       storage.ns_residuals.push_back(std::make_pair(0, 1.0));
       storage.ns_abs_tols.push_back(_turbulence_absolute_tolerance[i]);
     }
 
   if (_has_pm_radiation_systems && _should_solve_pm_radiation)
     for (const auto i : index_range(_pm_radiation_system_names))
     {
       storage.pm_radiation_indices.push_back(storage.ns_residuals.size());
       storage.ns_residuals.push_back(std::make_pair(0, 1.0));
       storage.ns_abs_tols.push_back(_pm_radiation_absolute_tolerance[i]);
     }
 
   storage.converged = storage.ns_residuals.empty();
   return storage;
 }

◆ solve()

bool LinearAssemblySegregatedSolve::solve ( )

overridevirtualinherited

Performs the momentum pressure coupling.

Returns: True if solver is converged.

Implements SolveObject.

Definition at line 635 of file LinearAssemblySegregatedSolve.C.

 {
   // 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;
 
   // We set up the residual storage and the corresponding tolerances.
   ResidualStorage residual_storage = setupResidualStorage();
   auto & ns_residuals = residual_storage.ns_residuals;
   auto & ns_abs_tols = residual_storage.ns_abs_tols;
   const auto & momentum_indices = residual_storage.momentum_indices;
   const auto pressure_index = residual_storage.pressure_index;
   const auto energy_index = residual_storage.energy_index;
   const auto solid_energy_index = residual_storage.solid_energy_index;
   const auto & active_scalar_indices = residual_storage.active_scalar_indices;
   const auto & turbulence_indices = residual_storage.turbulence_indices;
   const auto & pm_radiation_indices = residual_storage.pm_radiation_indices;
 
   bool converged = residual_storage.converged;
 
   // Loop until converged or hit the maximum allowed iteration number
   if (_cht.enabled() && _should_solve_energy)
     _cht.initializeCHTCouplingFields();
 
   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
     if (_should_solve_momentum)
       Moose::PetscSupport::petscSetOptions(_momentum_petsc_options, solver_params);
 
     // Initialize pressure gradients, after this we just reuse the last ones from each
     // iteration
     if (_should_solve_pressure && simple_iteration_counter == 1)
       _pressure_system.computeGradients();
 
     _console << "Iteration " << simple_iteration_counter << " Initial residual norms:" << std::endl;
 
     // Solve the momentum predictor step
     if (_should_solve_momentum)
     {
       auto momentum_residual = solveMomentumPredictor();
       for (const auto system_i : index_range(momentum_residual))
         ns_residuals[momentum_indices[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
     if (_should_solve_pressure)
       ns_residuals[pressure_index] = 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 && _should_solve_energy)
     {
       // If there is no CHT specified this will just do go once through this block
       _cht.resetCHTConvergence();
       while (!_cht.converged())
       {
         if (_cht.enabled())
           _cht.updateCHTBoundaryCouplingFields(NS::CHTSide::FLUID);
 
         // 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[energy_index] = solveAdvectedSystem(_energy_sys_number,
                                                          *_energy_system,
                                                          _energy_equation_relaxation,
                                                          _energy_linear_control,
                                                          _energy_l_abs_tol);
 
         if (_has_pm_radiation_systems && _should_solve_pm_radiation)
         {
           // We set the preconditioner/controllable parameters through petsc options. Linear
           // tolerances will be overridden within the solver.
           Moose::PetscSupport::petscSetOptions(_pm_radiation_petsc_options, solver_params);
           for (const auto i : index_range(_pm_radiation_system_names))
           {
             ns_residuals[pm_radiation_indices[i]] =
                 solveAdvectedSystem(_pm_radiation_system_numbers[i],
                                     *_pm_radiation_systems[i],
                                     _pm_radiation_equation_relaxation[i],
                                     _pm_radiation_linear_control,
                                     _pm_radiation_l_abs_tol);
           }
         }
 
         if (_has_solid_energy_system && _should_solve_solid_energy)
         {
           // For now we only update gradients if cht is needed, might change in the future
           if (_cht.enabled())
           {
             _energy_system->computeGradients();
             _cht.updateCHTBoundaryCouplingFields(NS::CHTSide::SOLID);
           }
 
           // 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[solid_energy_index] = solveSolidEnergy();
 
           // For now we only update gradients if cht is needed, might change in the future
           if (_cht.enabled())
             _solid_energy_system->computeGradients();
         }
 
         if (_cht.enabled())
         {
           _cht.sumIntegratedFluxes();
           _cht.printIntegratedFluxes();
         }
 
         _cht.incrementCHTIterators();
       }
       if (_cht.enabled())
         _cht.resetIntegratedFluxes();
     }
 
     // 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 && _should_solve_active_scalars)
     {
       _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[active_scalar_indices[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 && _should_solve_turbulence)
     {
       // 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[turbulence_indices[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 && _should_solve_passive_scalars &&
       (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()`
	)

protectedinherited

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

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

overrideprotectedvirtualinherited

Solve a momentum predictor step with a fixed pressure field.

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

Implements SIMPLESolveBase.

Definition at line 275 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::solve().

 {
   // 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 << " 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 ( )

overrideprotectedvirtualinherited

Solve a pressure corrector step.

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

Implements SIMPLESolveBase.

Definition at line 382 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::correctVelocity().

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

protectedinherited

Solve an equation which contains the solid energy conservation.

Definition at line 446 of file LinearAssemblySegregatedSolve.C.

Referenced by LinearAssemblySegregatedSolve::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

inlineinherited

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

Definition at line 41 of file LinearAssemblySegregatedSolve.h.

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

41 { return _systems_to_solve; }

LinearAssemblySegregatedSolve::_systems_to_solve

std::vector< LinearSystem * > _systems_to_solve

Shortcut to every linear system that we solve for here.

Definition: LinearAssemblySegregatedSolve.h:149

◆ validParams()

InputParameters PIMPLESolve::validParams ( )

static

Definition at line 18 of file PIMPLESolve.C.

Referenced by PIMPLE::validParams().

 {
   InputParameters params = LinearAssemblySegregatedSolve::validParams();
   params.addParam<unsigned int>(
       "num_piso_iterations",
       0,
       "The number of PISO iterations without recomputing the momentum matrix.");
 
   return params;
 }

Member Data Documentation

◆ _active_scalar_absolute_tolerance

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

protectedinherited

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

Definition at line 186 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::setupResidualStorage().

◆ _active_scalar_equation_relaxation

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

protectedinherited

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

Definition at line 173 of file LinearAssemblySegregatedSolve.h.

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

◆ _active_scalar_l_abs_tol

const Real LinearAssemblySegregatedSolve::_active_scalar_l_abs_tol

protectedinherited

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

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

Definition at line 183 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _active_scalar_linear_control

SIMPLESolverConfiguration LinearAssemblySegregatedSolve::_active_scalar_linear_control

protectedinherited

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

Definition at line 179 of file LinearAssemblySegregatedSolve.h.

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

◆ _active_scalar_petsc_options

Moose::PetscSupport::PetscOptions LinearAssemblySegregatedSolve::_active_scalar_petsc_options

protectedinherited

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

Definition at line 176 of file LinearAssemblySegregatedSolve.h.

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

◆ _active_scalar_system_names

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

protectedinherited

The names of the active scalar systems.

Definition at line 164 of file LinearAssemblySegregatedSolve.h.

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

◆ _active_scalar_system_numbers

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

protectedinherited

Definition at line 170 of file LinearAssemblySegregatedSolve.h.

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

◆ _active_scalar_systems

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

protectedinherited

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

Definition at line 140 of file LinearAssemblySegregatedSolve.h.

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

◆ _cht

NS::FV::CHTHandler LinearAssemblySegregatedSolve::_cht

protectedinherited

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

Definition at line 191 of file LinearAssemblySegregatedSolve.h.

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

◆ _continue_on_max_its

const bool SIMPLESolveBase::_continue_on_max_its

protectedinherited

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

Definition at line 262 of file SIMPLESolveBase.h.

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

◆ _energy_absolute_tolerance

const Real SIMPLESolveBase::_energy_absolute_tolerance

protectedinherited

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

Definition at line 244 of file SIMPLESolveBase.h.

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

◆ _energy_equation_relaxation

const Real SIMPLESolveBase::_energy_equation_relaxation

protectedinherited

The user-defined relaxation parameter for the energy equation.

Definition at line 130 of file SIMPLESolveBase.h.

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

◆ _energy_l_abs_tol

const Real SIMPLESolveBase::_energy_l_abs_tol

protectedinherited

Absolute linear tolerance for the energy equations.

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

Definition at line 140 of file SIMPLESolveBase.h.

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

◆ _energy_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_energy_linear_control

protectedinherited

Options for the linear solver of the energy equation.

Definition at line 136 of file SIMPLESolveBase.h.

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

◆ _energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_energy_petsc_options

protectedinherited

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

Definition at line 133 of file SIMPLESolveBase.h.

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

◆ _energy_sys_number

const unsigned int LinearAssemblySegregatedSolve::_energy_sys_number

protectedinherited

The number of the system corresponding to the energy equation.

Definition at line 122 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _energy_system

LinearSystem* LinearAssemblySegregatedSolve::_energy_system

protectedinherited

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

Definition at line 125 of file LinearAssemblySegregatedSolve.h.

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

◆ _has_active_scalar_systems

const bool LinearAssemblySegregatedSolve::_has_active_scalar_systems

protectedinherited

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

Definition at line 167 of file LinearAssemblySegregatedSolve.h.

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

◆ _has_energy_system

const bool SIMPLESolveBase::_has_energy_system

protectedinherited

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

Definition at line 127 of file SIMPLESolveBase.h.

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

◆ _has_passive_scalar_systems

const bool SIMPLESolveBase::_has_passive_scalar_systems

protectedinherited

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

Definition at line 163 of file SIMPLESolveBase.h.

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

◆ _has_pm_radiation_systems

const bool SIMPLESolveBase::_has_pm_radiation_systems

protectedinherited

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

Definition at line 187 of file SIMPLESolveBase.h.

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

◆ _has_solid_energy_system

const bool SIMPLESolveBase::_has_solid_energy_system

protectedinherited

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

Definition at line 145 of file SIMPLESolveBase.h.

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

◆ _has_turbulence_systems

const bool SIMPLESolveBase::_has_turbulence_systems

protectedinherited

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

Definition at line 211 of file SIMPLESolveBase.h.

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

◆ _momentum_absolute_tolerance

const Real SIMPLESolveBase::_momentum_absolute_tolerance

protectedinherited

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

Definition at line 238 of file SIMPLESolveBase.h.

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

◆ _momentum_equation_relaxation

const Real SIMPLESolveBase::_momentum_equation_relaxation

protectedinherited

The user-defined relaxation parameter for the momentum equation.

Definition at line 95 of file SIMPLESolveBase.h.

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

◆ _momentum_l_abs_tol

const Real SIMPLESolveBase::_momentum_l_abs_tol

protectedinherited

Absolute linear tolerance for the momentum equation(s).

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

Definition at line 89 of file SIMPLESolveBase.h.

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

◆ _momentum_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_momentum_linear_control

protectedinherited

Options for the linear solver of the momentum equation.

Definition at line 85 of file SIMPLESolveBase.h.

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

◆ _momentum_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_momentum_petsc_options

protectedinherited

Options which hold the petsc settings for the momentum equation.

Definition at line 92 of file SIMPLESolveBase.h.

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

◆ _momentum_system_names

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

protectedinherited

The names of the momentum systems.

Definition at line 82 of file SIMPLESolveBase.h.

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

◆ _momentum_system_numbers

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

protectedinherited

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

Definition at line 110 of file LinearAssemblySegregatedSolve.h.

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

◆ _momentum_systems

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

protectedinherited

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

Definition at line 113 of file LinearAssemblySegregatedSolve.h.

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

◆ _num_iterations

const unsigned int SIMPLESolveBase::_num_iterations

protectedinherited

The maximum number of momentum-pressure iterations.

Definition at line 259 of file SIMPLESolveBase.h.

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

◆ _num_piso_iterations

const unsigned int PIMPLESolve::_num_piso_iterations

protected

Number of H(u) and u iterations with fixed face flux.

Definition at line 45 of file PIMPLESolve.h.

Referenced by correctVelocity().

◆ _passive_scalar_absolute_tolerance

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

protectedinherited

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

Definition at line 250 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_equation_relaxation

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

protectedinherited

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

Definition at line 169 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_l_abs_tol

const Real SIMPLESolveBase::_passive_scalar_l_abs_tol

protectedinherited

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

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

Definition at line 179 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_passive_scalar_linear_control

protectedinherited

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

Definition at line 175 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_passive_scalar_petsc_options

protectedinherited

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

Definition at line 172 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_system_names

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

protectedinherited

The names of the passive scalar systems.

Definition at line 160 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_system_numbers

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

protectedinherited

Definition at line 166 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_systems

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

protectedinherited

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

Definition at line 134 of file LinearAssemblySegregatedSolve.h.

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

◆ _pin_pressure

const bool SIMPLESolveBase::_pin_pressure

protectedinherited

If the pressure needs to be pinned.

Definition at line 116 of file SIMPLESolveBase.h.

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

◆ _pm_radiation_absolute_tolerance

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

protectedinherited

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

Definition at line 253 of file SIMPLESolveBase.h.

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

◆ _pm_radiation_equation_relaxation

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

protectedinherited

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

Definition at line 193 of file SIMPLESolveBase.h.

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

◆ _pm_radiation_l_abs_tol

const Real SIMPLESolveBase::_pm_radiation_l_abs_tol

protectedinherited

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

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

Definition at line 203 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _pm_radiation_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_pm_radiation_linear_control

protectedinherited

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

Definition at line 199 of file SIMPLESolveBase.h.

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

◆ _pm_radiation_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_pm_radiation_petsc_options

protectedinherited

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

Definition at line 196 of file SIMPLESolveBase.h.

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

◆ _pm_radiation_system_names

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

protectedinherited

The names of the participating media radiation systems.

Definition at line 184 of file SIMPLESolveBase.h.

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

◆ _pm_radiation_system_numbers

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

protectedinherited

Definition at line 190 of file SIMPLESolveBase.h.

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

◆ _pm_radiation_systems

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

protectedinherited

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

Definition at line 137 of file LinearAssemblySegregatedSolve.h.

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

◆ _pressure_absolute_tolerance

const Real SIMPLESolveBase::_pressure_absolute_tolerance

protectedinherited

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

Definition at line 241 of file SIMPLESolveBase.h.

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

◆ _pressure_l_abs_tol

const Real SIMPLESolveBase::_pressure_l_abs_tol

protectedinherited

Absolute linear tolerance for the pressure equation.

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

Definition at line 107 of file SIMPLESolveBase.h.

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

◆ _pressure_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_pressure_linear_control

protectedinherited

Options for the linear solver of the pressure equation.

Definition at line 103 of file SIMPLESolveBase.h.

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

◆ _pressure_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_pressure_petsc_options

protectedinherited

Options which hold the petsc settings for the pressure equation.

Definition at line 110 of file SIMPLESolveBase.h.

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

◆ _pressure_pin_dof

dof_id_type SIMPLESolveBase::_pressure_pin_dof

protectedinherited

The dof ID where the pressure needs to be pinned.

Definition at line 122 of file SIMPLESolveBase.h.

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

◆ _pressure_pin_value

const Real SIMPLESolveBase::_pressure_pin_value

protectedinherited

The value we want to enforce for pressure.

Definition at line 119 of file SIMPLESolveBase.h.

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

◆ _pressure_sys_number

const unsigned int LinearAssemblySegregatedSolve::_pressure_sys_number

protectedinherited

The number of the system corresponding to the pressure equation.

Definition at line 116 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solvePressureCorrector().

◆ _pressure_system

LinearSystem& LinearAssemblySegregatedSolve::_pressure_system

protectedinherited

Reference to the linear system corresponding to the pressure equation.

Definition at line 119 of file LinearAssemblySegregatedSolve.h.

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

◆ _pressure_system_name

const SolverSystemName& SIMPLESolveBase::_pressure_system_name

protectedinherited

The name of the pressure system.

Definition at line 100 of file SIMPLESolveBase.h.

◆ _pressure_variable_relaxation

const Real SIMPLESolveBase::_pressure_variable_relaxation

protectedinherited

The user-defined relaxation parameter for the pressure variable.

Definition at line 113 of file SIMPLESolveBase.h.

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

◆ _print_fields

const bool SIMPLESolveBase::_print_fields

protectedinherited

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

Definition at line 267 of file SIMPLESolveBase.h.

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

◆ _rc_uo

RhieChowMassFlux* LinearAssemblySegregatedSolve::_rc_uo

protectedinherited

Pointer to the segregated RhieChow interpolation object.

Definition at line 146 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_active_scalars

const bool LinearAssemblySegregatedSolve::_should_solve_active_scalars

protectedinherited

Definition at line 158 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_energy

const bool LinearAssemblySegregatedSolve::_should_solve_energy

protectedinherited

Definition at line 154 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_momentum

const bool LinearAssemblySegregatedSolve::_should_solve_momentum

protectedinherited

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

Definition at line 152 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_passive_scalars

const bool LinearAssemblySegregatedSolve::_should_solve_passive_scalars

protectedinherited

Definition at line 157 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_pm_radiation

const bool LinearAssemblySegregatedSolve::_should_solve_pm_radiation

protectedinherited

Definition at line 159 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_pressure

const bool LinearAssemblySegregatedSolve::_should_solve_pressure

protectedinherited

Definition at line 153 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_solid_energy

const bool LinearAssemblySegregatedSolve::_should_solve_solid_energy

protectedinherited

Definition at line 155 of file LinearAssemblySegregatedSolve.h.

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

◆ _should_solve_turbulence

const bool LinearAssemblySegregatedSolve::_should_solve_turbulence

protectedinherited

Definition at line 156 of file LinearAssemblySegregatedSolve.h.

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

◆ _solid_energy_absolute_tolerance

const Real SIMPLESolveBase::_solid_energy_absolute_tolerance

protectedinherited

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

Definition at line 247 of file SIMPLESolveBase.h.

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

◆ _solid_energy_l_abs_tol

const Real SIMPLESolveBase::_solid_energy_l_abs_tol

protectedinherited

Absolute linear tolerance for the energy equations.

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

Definition at line 155 of file SIMPLESolveBase.h.

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

◆ _solid_energy_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_solid_energy_linear_control

protectedinherited

Options for the linear solver of the energy equation.

Definition at line 151 of file SIMPLESolveBase.h.

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

◆ _solid_energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_solid_energy_petsc_options

protectedinherited

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

Definition at line 148 of file SIMPLESolveBase.h.

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

◆ _solid_energy_sys_number

const unsigned int LinearAssemblySegregatedSolve::_solid_energy_sys_number

protectedinherited

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

Definition at line 128 of file LinearAssemblySegregatedSolve.h.

Referenced by LinearAssemblySegregatedSolve::solveSolidEnergy().

◆ _solid_energy_system

LinearSystem* LinearAssemblySegregatedSolve::_solid_energy_system

protectedinherited

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

Definition at line 131 of file LinearAssemblySegregatedSolve.h.

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

◆ _systems_to_solve

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

protectedinherited

Shortcut to every linear system that we solve for here.

Definition at line 149 of file LinearAssemblySegregatedSolve.h.

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

◆ _turbulence_absolute_tolerance

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

protectedinherited

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

Definition at line 256 of file SIMPLESolveBase.h.

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

◆ _turbulence_equation_relaxation

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

protectedinherited

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

Definition at line 217 of file SIMPLESolveBase.h.

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

◆ _turbulence_field_min_limit

std::vector<Real> SIMPLESolveBase::_turbulence_field_min_limit

protectedinherited

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

Definition at line 223 of file SIMPLESolveBase.h.

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

◆ _turbulence_field_relaxation

std::vector<Real> SIMPLESolveBase::_turbulence_field_relaxation

protectedinherited

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

Definition at line 220 of file SIMPLESolveBase.h.

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

◆ _turbulence_l_abs_tol

const Real SIMPLESolveBase::_turbulence_l_abs_tol

protectedinherited

Absolute linear tolerance for the turbulence equation(s).

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

Definition at line 233 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _turbulence_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_turbulence_linear_control

protectedinherited

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

Definition at line 229 of file SIMPLESolveBase.h.

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

◆ _turbulence_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_turbulence_petsc_options

protectedinherited

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

Definition at line 226 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_names

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

protectedinherited

The names of the turbulence systems.

Definition at line 208 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_numbers

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

protectedinherited

Definition at line 214 of file SIMPLESolveBase.h.

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

◆ _turbulence_systems

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

protectedinherited

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

Definition at line 143 of file LinearAssemblySegregatedSolve.h.

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

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

navier_stokes/include/executioners/PIMPLESolve.h
navier_stokes/src/executioners/PIMPLESolve.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

◆ PIMPLESolve()

Member Function Documentation

◆ checkDependentParameterError()

◆ checkIntegrity()

◆ correctVelocity()

◆ initialSetup()

◆ linkRhieChowUserObject()

◆ setInnerSolve()

◆ setupPressurePin()

◆ setupResidualStorage()

◆ 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

◆ _cht

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

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

◆ _pm_radiation_absolute_tolerance

◆ _pm_radiation_equation_relaxation

◆ _pm_radiation_l_abs_tol

◆ _pm_radiation_linear_control

◆ _pm_radiation_petsc_options

◆ _pm_radiation_system_names

◆ _pm_radiation_system_numbers

◆ _pm_radiation_systems

◆ _pressure_absolute_tolerance

◆ _pressure_l_abs_tol

◆ _pressure_linear_control