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

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

#include <SIMPLESolveBase.h>

Inheritance diagram for SIMPLESolveBase:
[legend]

Public Types

typedef DataFileName DataFileParameterType
 

Public Member Functions

 SIMPLESolveBase (Executioner &ex)
 
virtual void setInnerSolve (SolveObject &) override
 
virtual void linkRhieChowUserObject ()=0
 Fetch the Rhie Chow user object that is reponsible for determining face velocities and mass flux. More...
 
void setupPressurePin ()
 Setup pressure pin if there is need for one. More...
 
virtual void checkIntegrity ()
 Check if the user defined time kernels. More...
 
virtual void initialSetup ()
 
virtual bool solve ()=0
 
virtual bool enabled () const
 
std::shared_ptr< MooseObject > getSharedPtr ()
 
std::shared_ptr< const MooseObject > getSharedPtr () const
 
MooseApp & getMooseApp () const
 
const std::string & type () const
 
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

void checkDependentParameterError (const std::string &main_parameter, const std::vector< std::string > &dependent_parameters, const bool should_be_defined)
 
virtual std::vector< std::pair< unsigned int, Real > > solveMomentumPredictor ()=0
 Solve a momentum predictor step with a fixed pressure field. More...
 
virtual std::pair< unsigned int, Real > solvePressureCorrector ()=0
 Solve a pressure corrector step. More...
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 
std::string timedSectionName (const std::string &section_name) const
 
virtual void addPostprocessorDependencyHelper (const PostprocessorName &) const
 
virtual void addUserObjectDependencyHelper (const UserObject &) const
 

Protected Attributes

const std::vector< SolverSystemName > & _momentum_system_names
 The names of the momentum systems. More...
 
SIMPLESolverConfiguration _momentum_linear_control
 Options for the linear solver of the momentum equation. More...
 
const Real _momentum_l_abs_tol
 Absolute linear tolerance for the momentum equation(s). More...
 
Moose::PetscSupport::PetscOptions _momentum_petsc_options
 Options which hold the petsc settings for the momentum equation. More...
 
const Real _momentum_equation_relaxation
 The user-defined relaxation parameter for the momentum equation. More...
 
const SolverSystemName & _pressure_system_name
 The name of the pressure system. More...
 
SIMPLESolverConfiguration _pressure_linear_control
 Options for the linear solver of the pressure equation. More...
 
const Real _pressure_l_abs_tol
 Absolute linear tolerance for the pressure equation. More...
 
Moose::PetscSupport::PetscOptions _pressure_petsc_options
 Options which hold the petsc settings for the pressure equation. More...
 
const Real _pressure_variable_relaxation
 The user-defined relaxation parameter for the pressure variable. More...
 
const bool _pin_pressure
 If the pressure needs to be pinned. More...
 
const Real _pressure_pin_value
 The value we want to enforce for pressure. More...
 
dof_id_type _pressure_pin_dof
 The dof ID where the pressure needs to be pinned. More...
 
const bool _has_energy_system
 Boolean for easy check if a fluid energy system shall be solved or not. More...
 
const Real _energy_equation_relaxation
 The user-defined relaxation parameter for the energy equation. More...
 
Moose::PetscSupport::PetscOptions _energy_petsc_options
 Options which hold the petsc settings for the fluid energy equation. More...
 
SIMPLESolverConfiguration _energy_linear_control
 Options for the linear solver of the energy equation. More...
 
const Real _energy_l_abs_tol
 Absolute linear tolerance for the energy equations. More...
 
const bool _has_solid_energy_system
 Boolean for easy check if a solid energy system shall be solved or not. More...
 
Moose::PetscSupport::PetscOptions _solid_energy_petsc_options
 Options which hold the petsc settings for the fluid energy equation. More...
 
SIMPLESolverConfiguration _solid_energy_linear_control
 Options for the linear solver of the energy equation. More...
 
const Real _solid_energy_l_abs_tol
 Absolute linear tolerance for the energy equations. More...
 
const std::vector< SolverSystemName > & _passive_scalar_system_names
 The names of the passive scalar systems. More...
 
const bool _has_passive_scalar_systems
 Boolean for easy check if a passive scalar systems shall be solved or not. More...
 
std::vector< unsigned int > _passive_scalar_system_numbers
 
const std::vector< Real > _passive_scalar_equation_relaxation
 The user-defined relaxation parameter(s) for the passive scalar equation(s) More...
 
Moose::PetscSupport::PetscOptions _passive_scalar_petsc_options
 Options which hold the petsc settings for the passive scalar equation(s) More...
 
SIMPLESolverConfiguration _passive_scalar_linear_control
 Options for the linear solver of the passive scalar equation(s) More...
 
const Real _passive_scalar_l_abs_tol
 Absolute linear tolerance for the passive scalar equation(s). More...
 
const std::vector< SolverSystemName > & _turbulence_system_names
 The names of the turbulence systems. More...
 
const bool _has_turbulence_systems
 Boolean for easy check if a turbulence scalar systems shall be solved or not. More...
 
std::vector< unsigned int > _turbulence_system_numbers
 
const std::vector< Real > _turbulence_equation_relaxation
 The user-defined relaxation parameter(s) for the turbulence equation(s) More...
 
std::vector< Real > _turbulence_field_relaxation
 The user-defined relaxation parameter(s) for the turbulence field(s) More...
 
std::vector< Real > _turbulence_field_min_limit
 The user-defined lower limit for turbulent quantities e.g. k, eps/omega, etc.. More...
 
Moose::PetscSupport::PetscOptions _turbulence_petsc_options
 Options which hold the petsc settings for the turbulence equation(s) More...
 
SIMPLESolverConfiguration _turbulence_linear_control
 Options for the linear solver of the turbulence equation(s) More...
 
const Real _turbulence_l_abs_tol
 Absolute linear tolerance for the turbulence equation(s). More...
 
const Real _momentum_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in momentum. More...
 
const Real _pressure_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in pressure. More...
 
const Real _energy_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in energy. More...
 
const Real _solid_energy_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in solid energy. More...
 
const std::vector< Real > _passive_scalar_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence in passive scalars. More...
 
const std::vector< Real > _turbulence_absolute_tolerance
 The user-defined absolute tolerance for determining the convergence turbulence variables. More...
 
const unsigned int _num_iterations
 The maximum number of momentum-pressure iterations. More...
 
const bool _continue_on_max_its
 If solve should continue if maximum number of iterations is hit. More...
 
const bool _print_fields
 Debug parameter which allows printing the coupling and solution vectors/matrices. More...
 
Executioner & _executioner
 
FEProblemBase & _problem
 
DisplacedProblem * _displaced_problem
 
MooseMesh & _mesh
 
MooseMesh * _displaced_mesh
 
SystemBase & _solver_sys
 
AuxiliarySystem & _aux
 
SolveObject * _inner_solve
 
const bool & _enabled
 
MooseApp & _app
 
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

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

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

Definition at line 41 of file SIMPLESolveBase.h.

Constructor & Destructor Documentation

◆ SIMPLESolveBase()

SIMPLESolveBase::SIMPLESolveBase ( Executioner &  ex)

Definition at line 365 of file SIMPLESolveBase.C.

366  : SolveObject(ex),
367  UserObjectInterface(this),
368  _momentum_system_names(getParam<std::vector<SolverSystemName>>("momentum_systems")),
369  _momentum_l_abs_tol(getParam<Real>("momentum_l_abs_tol")),
370  _momentum_equation_relaxation(getParam<Real>("momentum_equation_relaxation")),
371  _pressure_system_name(getParam<SolverSystemName>("pressure_system")),
372  _pressure_l_abs_tol(getParam<Real>("pressure_l_abs_tol")),
373  _pressure_variable_relaxation(getParam<Real>("pressure_variable_relaxation")),
374  _pin_pressure(getParam<bool>("pin_pressure")),
375  _pressure_pin_value(getParam<Real>("pressure_pin_value")),
376  _pressure_pin_dof(libMesh::invalid_uint),
377  _has_energy_system(isParamValid("energy_system")),
378  _energy_equation_relaxation(getParam<Real>("energy_equation_relaxation")),
379  _energy_l_abs_tol(getParam<Real>("energy_l_abs_tol")),
380  _has_solid_energy_system(_has_energy_system && isParamValid("solid_energy_system")),
381  _solid_energy_l_abs_tol(getParam<Real>("solid_energy_l_abs_tol")),
382  _passive_scalar_system_names(getParam<std::vector<SolverSystemName>>("passive_scalar_systems")),
383  _has_passive_scalar_systems(!_passive_scalar_system_names.empty()),
384  _passive_scalar_equation_relaxation(
385  getParam<std::vector<Real>>("passive_scalar_equation_relaxation")),
386  _passive_scalar_l_abs_tol(getParam<Real>("passive_scalar_l_abs_tol")),
387  _turbulence_system_names(getParam<std::vector<SolverSystemName>>("turbulence_systems")),
388  _has_turbulence_systems(!_turbulence_system_names.empty()),
389  _turbulence_equation_relaxation(getParam<std::vector<Real>>("turbulence_equation_relaxation")),
390  _turbulence_field_relaxation(getParam<std::vector<Real>>("turbulence_field_relaxation")),
391  _turbulence_field_min_limit(getParam<std::vector<Real>>("turbulence_field_min_limit")),
392  _turbulence_l_abs_tol(getParam<Real>("turbulence_l_abs_tol")),
393  _momentum_absolute_tolerance(getParam<Real>("momentum_absolute_tolerance")),
394  _pressure_absolute_tolerance(getParam<Real>("pressure_absolute_tolerance")),
395  _energy_absolute_tolerance(getParam<Real>("energy_absolute_tolerance")),
396  _solid_energy_absolute_tolerance(getParam<Real>("solid_energy_absolute_tolerance")),
397  _passive_scalar_absolute_tolerance(
398  getParam<std::vector<Real>>("passive_scalar_absolute_tolerance")),
399  _turbulence_absolute_tolerance(getParam<std::vector<Real>>("turbulence_absolute_tolerance")),
400  _num_iterations(getParam<unsigned int>("num_iterations")),
401  _continue_on_max_its(getParam<bool>("continue_on_max_its")),
402  _print_fields(getParam<bool>("print_fields"))
403 {
404  if (_momentum_system_names.size() != _problem.mesh().dimension())
405  paramError("momentum_systems",
406  "The number of momentum components should be equal to the number of "
407  "spatial dimensions on the mesh.");
408 
409  const auto & momentum_petsc_options = getParam<MultiMooseEnum>("momentum_petsc_options");
410  const auto & momentum_petsc_pair_options = getParam<MooseEnumItem, std::string>(
411  "momentum_petsc_options_iname", "momentum_petsc_options_value");
412  Moose::PetscSupport::addPetscFlagsToPetscOptions(
413  momentum_petsc_options, "-", *this, _momentum_petsc_options);
414  Moose::PetscSupport::addPetscPairsToPetscOptions(momentum_petsc_pair_options,
415  _problem.mesh().dimension(),
416  "-",
417  *this,
418  _momentum_petsc_options);
419 
420  _momentum_linear_control.real_valued_data["rel_tol"] = getParam<Real>("momentum_l_tol");
421  _momentum_linear_control.real_valued_data["abs_tol"] = getParam<Real>("momentum_l_abs_tol");
422  _momentum_linear_control.int_valued_data["max_its"] =
423  getParam<unsigned int>("momentum_l_max_its");
424 
425  const auto & pressure_petsc_options = getParam<MultiMooseEnum>("pressure_petsc_options");
426  const auto & pressure_petsc_pair_options = getParam<MooseEnumItem, std::string>(
427  "pressure_petsc_options_iname", "pressure_petsc_options_value");
428  Moose::PetscSupport::addPetscFlagsToPetscOptions(
429  pressure_petsc_options, "-", *this, _pressure_petsc_options);
430  Moose::PetscSupport::addPetscPairsToPetscOptions(pressure_petsc_pair_options,
431  _problem.mesh().dimension(),
432  "-",
433  *this,
434  _pressure_petsc_options);
435 
436  _pressure_linear_control.real_valued_data["rel_tol"] = getParam<Real>("pressure_l_tol");
437  _pressure_linear_control.real_valued_data["abs_tol"] = getParam<Real>("pressure_l_abs_tol");
438  _pressure_linear_control.int_valued_data["max_its"] =
439  getParam<unsigned int>("pressure_l_max_its");
440 
441  if (_has_energy_system)
442  {
443  const auto & energy_petsc_options = getParam<MultiMooseEnum>("energy_petsc_options");
444  const auto & energy_petsc_pair_options = getParam<MooseEnumItem, std::string>(
445  "energy_petsc_options_iname", "energy_petsc_options_value");
446  Moose::PetscSupport::addPetscFlagsToPetscOptions(
447  energy_petsc_options, "-", *this, _energy_petsc_options);
448  Moose::PetscSupport::addPetscPairsToPetscOptions(
449  energy_petsc_pair_options, _problem.mesh().dimension(), "-", *this, _energy_petsc_options);
450 
451  _energy_linear_control.real_valued_data["rel_tol"] = getParam<Real>("energy_l_tol");
452  _energy_linear_control.real_valued_data["abs_tol"] = getParam<Real>("energy_l_abs_tol");
453  _energy_linear_control.int_valued_data["max_its"] = getParam<unsigned int>("energy_l_max_its");
454  }
455  else
456  checkDependentParameterError("energy_system",
457  {"energy_petsc_options",
458  "energy_petsc_options_iname",
459  "energy_petsc_options_value",
460  "energy_l_tol",
461  "energy_l_abs_tol",
462  "energy_l_max_its",
463  "energy_absolute_tolerance",
464  "energy_equation_relaxation"},
465  false);
466 
467  if (_has_solid_energy_system)
468  {
469  const auto & solid_energy_petsc_options =
470  getParam<MultiMooseEnum>("solid_energy_petsc_options");
471  const auto & solid_energy_petsc_pair_options = getParam<MooseEnumItem, std::string>(
472  "solid_energy_petsc_options_iname", "solid_energy_petsc_options_value");
473  Moose::PetscSupport::addPetscFlagsToPetscOptions(
474  solid_energy_petsc_options, "-", *this, _solid_energy_petsc_options);
475  Moose::PetscSupport::addPetscPairsToPetscOptions(solid_energy_petsc_pair_options,
476  _problem.mesh().dimension(),
477  "-",
478  *this,
479  _solid_energy_petsc_options);
480 
481  _solid_energy_linear_control.real_valued_data["rel_tol"] = getParam<Real>("solid_energy_l_tol");
482  _solid_energy_linear_control.real_valued_data["abs_tol"] =
483  getParam<Real>("solid_energy_l_abs_tol");
484  _solid_energy_linear_control.int_valued_data["max_its"] =
485  getParam<unsigned int>("solid_energy_l_max_its");
486  }
487  else
488  checkDependentParameterError("solid_energy_system",
489  {"solid_energy_petsc_options",
490  "solid_energy_petsc_options_iname",
491  "solid_energy_petsc_options_value",
492  "solid_energy_l_tol",
493  "solid_energy_l_abs_tol",
494  "solid_energy_l_max_its",
495  "solid_energy_absolute_tolerance",
496  "solid_energy_equation_relaxation"},
497  false);
498 
499  // We check for input errors with regards to the passive scalar equations. At the same time, we
500  // set up the corresponding system numbers
501  if (_has_passive_scalar_systems)
502  {
503  if (_passive_scalar_system_names.size() != _passive_scalar_equation_relaxation.size())
504  paramError("passive_scalar_equation_relaxation",
505  "The number of equation relaxation parameters does not match the number of "
506  "passive scalar equations!");
507  if (_passive_scalar_system_names.size() != _passive_scalar_absolute_tolerance.size())
508  paramError("passive_scalar_absolute_tolerance",
509  "The number of absolute tolerances does not match the number of "
510  "passive scalar equations!");
511  }
512  if (_has_passive_scalar_systems)
513  {
514  const auto & passive_scalar_petsc_options =
515  getParam<MultiMooseEnum>("passive_scalar_petsc_options");
516  const auto & passive_scalar_petsc_pair_options = getParam<MooseEnumItem, std::string>(
517  "passive_scalar_petsc_options_iname", "passive_scalar_petsc_options_value");
518  Moose::PetscSupport::addPetscFlagsToPetscOptions(
519  passive_scalar_petsc_options, "-", *this, _passive_scalar_petsc_options);
520  Moose::PetscSupport::addPetscPairsToPetscOptions(passive_scalar_petsc_pair_options,
521  _problem.mesh().dimension(),
522  "-",
523  *this,
524  _passive_scalar_petsc_options);
525 
526  _passive_scalar_linear_control.real_valued_data["rel_tol"] =
527  getParam<Real>("passive_scalar_l_tol");
528  _passive_scalar_linear_control.real_valued_data["abs_tol"] =
529  getParam<Real>("passive_scalar_l_abs_tol");
530  _passive_scalar_linear_control.int_valued_data["max_its"] =
531  getParam<unsigned int>("passive_scalar_l_max_its");
532  }
533  else
534  checkDependentParameterError("passive_scalar_systems",
535  {"passive_scalar_petsc_options",
536  "passive_scalar_petsc_options_iname",
537  "passive_scalar_petsc_options_value",
538  "passive_scalar_l_tol",
539  "passive_scalar_l_abs_tol",
540  "passive_scalar_l_max_its",
541  "passive_scalar_equation_relaxation",
542  "passive_scalar_absolute_tolerance"},
543  false);
544 
545  // We check for input errors with regards to the surrogate turbulence equations. At the same time,
546  // we set up the corresponding system numbers
547  if (_has_turbulence_systems)
548  {
549  if (_turbulence_system_names.size() != _turbulence_equation_relaxation.size())
550  paramError("turbulence_equation_relaxation",
551  "The number of equation relaxation parameters does not match the number of "
552  "turbulence equations!");
553  if (_turbulence_system_names.size() != _turbulence_absolute_tolerance.size())
554  paramError("turbulence_absolute_tolerance",
555  "The number of absolute tolerances does not match the number of "
556  "turbulence equations!");
557  if (_turbulence_field_min_limit.empty())
558  // If no minimum bounds are given, initialize to default value 1e-8
559  _turbulence_field_min_limit.resize(_turbulence_system_names.size(), 1e-8);
560 
561  // Assign turbulence field relaxation as 1.0 if not defined
562  if (_turbulence_field_relaxation.empty())
563  _turbulence_field_relaxation.resize(_turbulence_system_names.size(), 1.0);
564 
565  const auto & turbulence_petsc_options = getParam<MultiMooseEnum>("turbulence_petsc_options");
566  const auto & turbulence_petsc_pair_options = getParam<MooseEnumItem, std::string>(
567  "turbulence_petsc_options_iname", "turbulence_petsc_options_value");
568  Moose::PetscSupport::addPetscFlagsToPetscOptions(
569  turbulence_petsc_options, "-", *this, _turbulence_petsc_options);
570  Moose::PetscSupport::addPetscPairsToPetscOptions(turbulence_petsc_pair_options,
571  _problem.mesh().dimension(),
572  "-",
573  *this,
574  _turbulence_petsc_options);
575 
576  _turbulence_linear_control.real_valued_data["rel_tol"] = getParam<Real>("turbulence_l_tol");
577  _turbulence_linear_control.real_valued_data["abs_tol"] = getParam<Real>("turbulence_l_abs_tol");
578  _turbulence_linear_control.int_valued_data["max_its"] =
579  getParam<unsigned int>("turbulence_l_max_its");
580  }
581  else
582  checkDependentParameterError("turbulence_systems",
583  {"turbulence_petsc_options",
584  "turbulence_petsc_options_iname",
585  "turbulence_petsc_options_value",
586  "turbulence_l_tol",
587  "turbulence_l_abs_tol",
588  "turbulence_l_max_its",
589  "turbulence_equation_relaxation",
590  "turbulence_field_relaxation",
591  "turbulence_field_min_limit",
592  "turbulence_absolute_tolerance"},
593  false);
594 }
SolveObject::_problem
FEProblemBase & _problem
SIMPLESolveBase::_momentum_linear_control
SIMPLESolverConfiguration _momentum_linear_control
Options for the linear solver of the momentum equation.
Definition: SIMPLESolveBase.h:85
SIMPLESolveBase::_turbulence_linear_control
SIMPLESolverConfiguration _turbulence_linear_control
Options for the linear solver of the turbulence equation(s)
Definition: SIMPLESolveBase.h:205
SIMPLESolveBase::_energy_absolute_tolerance
const Real _energy_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in energy.
Definition: SIMPLESolveBase.h:220
SIMPLESolveBase::_num_iterations
const unsigned int _num_iterations
The maximum number of momentum-pressure iterations.
Definition: SIMPLESolveBase.h:232
SIMPLESolveBase::_energy_linear_control
SIMPLESolverConfiguration _energy_linear_control
Options for the linear solver of the energy equation.
Definition: SIMPLESolveBase.h:136
libMesh::invalid_uint
const unsigned int invalid_uint
SIMPLESolveBase::_print_fields
const bool _print_fields
Debug parameter which allows printing the coupling and solution vectors/matrices. ...
Definition: SIMPLESolveBase.h:240
SIMPLESolveBase::_turbulence_petsc_options
Moose::PetscSupport::PetscOptions _turbulence_petsc_options
Options which hold the petsc settings for the turbulence equation(s)
Definition: SIMPLESolveBase.h:202
SIMPLESolveBase::_solid_energy_l_abs_tol
const Real _solid_energy_l_abs_tol
Absolute linear tolerance for the energy equations.
Definition: SIMPLESolveBase.h:155
SIMPLESolveBase::_has_energy_system
const bool _has_energy_system
Boolean for easy check if a fluid energy system shall be solved or not.
Definition: SIMPLESolveBase.h:127
SIMPLESolveBase::_pressure_system_name
const SolverSystemName & _pressure_system_name
The name of the pressure system.
Definition: SIMPLESolveBase.h:100
SIMPLESolveBase::_turbulence_field_relaxation
std::vector< Real > _turbulence_field_relaxation
The user-defined relaxation parameter(s) for the turbulence field(s)
Definition: SIMPLESolveBase.h:196
SIMPLESolveBase::_passive_scalar_l_abs_tol
const Real _passive_scalar_l_abs_tol
Absolute linear tolerance for the passive scalar equation(s).
Definition: SIMPLESolveBase.h:179
SIMPLESolveBase::_solid_energy_petsc_options
Moose::PetscSupport::PetscOptions _solid_energy_petsc_options
Options which hold the petsc settings for the fluid energy equation.
Definition: SIMPLESolveBase.h:148
SIMPLESolveBase::_momentum_equation_relaxation
const Real _momentum_equation_relaxation
The user-defined relaxation parameter for the momentum equation.
Definition: SIMPLESolveBase.h:95
SIMPLESolveBase::_has_turbulence_systems
const bool _has_turbulence_systems
Boolean for easy check if a turbulence scalar systems shall be solved or not.
Definition: SIMPLESolveBase.h:187
SIMPLESolveBase::checkDependentParameterError
void checkDependentParameterError(const std::string &main_parameter, const std::vector< std::string > &dependent_parameters, const bool should_be_defined)
Definition: SIMPLESolveBase.C:606
SIMPLESolveBase::_momentum_l_abs_tol
const Real _momentum_l_abs_tol
Absolute linear tolerance for the momentum equation(s).
Definition: SIMPLESolveBase.h:89
libMesh::SolverConfiguration::real_valued_data
std::map< std::string, Real > real_valued_data
SIMPLESolveBase::_pressure_absolute_tolerance
const Real _pressure_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in pressure.
Definition: SIMPLESolveBase.h:217
SolveObject::isParamValid
bool isParamValid(const std::string &name) const
SIMPLESolveBase::_pressure_variable_relaxation
const Real _pressure_variable_relaxation
The user-defined relaxation parameter for the pressure variable.
Definition: SIMPLESolveBase.h:113
SIMPLESolveBase::_momentum_absolute_tolerance
const Real _momentum_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in momentum.
Definition: SIMPLESolveBase.h:214
SIMPLESolveBase::_passive_scalar_system_names
const std::vector< SolverSystemName > & _passive_scalar_system_names
The names of the passive scalar systems.
Definition: SIMPLESolveBase.h:160
SIMPLESolveBase::_passive_scalar_linear_control
SIMPLESolverConfiguration _passive_scalar_linear_control
Options for the linear solver of the passive scalar equation(s)
Definition: SIMPLESolveBase.h:175
SIMPLESolveBase::_energy_petsc_options
Moose::PetscSupport::PetscOptions _energy_petsc_options
Options which hold the petsc settings for the fluid energy equation.
Definition: SIMPLESolveBase.h:133
SIMPLESolveBase::_pressure_linear_control
SIMPLESolverConfiguration _pressure_linear_control
Options for the linear solver of the pressure equation.
Definition: SIMPLESolveBase.h:103
SIMPLESolveBase::_passive_scalar_petsc_options
Moose::PetscSupport::PetscOptions _passive_scalar_petsc_options
Options which hold the petsc settings for the passive scalar equation(s)
Definition: SIMPLESolveBase.h:172
MooseMesh::dimension
virtual unsigned int dimension() const
libMesh::SolverConfiguration::int_valued_data
std::map< std::string, int > int_valued_data
SIMPLESolveBase::_momentum_petsc_options
Moose::PetscSupport::PetscOptions _momentum_petsc_options
Options which hold the petsc settings for the momentum equation.
Definition: SIMPLESolveBase.h:92
SIMPLESolveBase::_pressure_l_abs_tol
const Real _pressure_l_abs_tol
Absolute linear tolerance for the pressure equation.
Definition: SIMPLESolveBase.h:107
SIMPLESolveBase::_passive_scalar_absolute_tolerance
const std::vector< Real > _passive_scalar_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in passive scalars.
Definition: SIMPLESolveBase.h:226
SIMPLESolveBase::_pressure_pin_dof
dof_id_type _pressure_pin_dof
The dof ID where the pressure needs to be pinned.
Definition: SIMPLESolveBase.h:122
SolveObject::getParam
const T & getParam(const std::string &name) const
SIMPLESolveBase::_turbulence_system_names
const std::vector< SolverSystemName > & _turbulence_system_names
The names of the turbulence systems.
Definition: SIMPLESolveBase.h:184
SIMPLESolveBase::_pin_pressure
const bool _pin_pressure
If the pressure needs to be pinned.
Definition: SIMPLESolveBase.h:116
SolveObject::paramError
void paramError(const std::string &param, Args... args) const
SIMPLESolveBase::_energy_l_abs_tol
const Real _energy_l_abs_tol
Absolute linear tolerance for the energy equations.
Definition: SIMPLESolveBase.h:140
SolveObject::SolveObject
SolveObject(Executioner &ex)
SIMPLESolveBase::_turbulence_equation_relaxation
const std::vector< Real > _turbulence_equation_relaxation
The user-defined relaxation parameter(s) for the turbulence equation(s)
Definition: SIMPLESolveBase.h:193
SIMPLESolveBase::_momentum_system_names
const std::vector< SolverSystemName > & _momentum_system_names
The names of the momentum systems.
Definition: SIMPLESolveBase.h:82
SIMPLESolveBase::_passive_scalar_equation_relaxation
const std::vector< Real > _passive_scalar_equation_relaxation
The user-defined relaxation parameter(s) for the passive scalar equation(s)
Definition: SIMPLESolveBase.h:169
Moose::PetscSupport::addPetscPairsToPetscOptions
void addPetscPairsToPetscOptions(const std::vector< std::pair< MooseEnumItem, std::string >> &petsc_pair_options, const unsigned int mesh_dimension, const std::string &prefix, const ParallelParamObject &param_object, PetscOptions &petsc_options)
SIMPLESolveBase::_energy_equation_relaxation
const Real _energy_equation_relaxation
The user-defined relaxation parameter for the energy equation.
Definition: SIMPLESolveBase.h:130
SIMPLESolveBase::_pressure_pin_value
const Real _pressure_pin_value
The value we want to enforce for pressure.
Definition: SIMPLESolveBase.h:119
SIMPLESolveBase::_turbulence_l_abs_tol
const Real _turbulence_l_abs_tol
Absolute linear tolerance for the turbulence equation(s).
Definition: SIMPLESolveBase.h:209
FEProblemBase::mesh
virtual MooseMesh & mesh() override
SIMPLESolveBase::_has_passive_scalar_systems
const bool _has_passive_scalar_systems
Boolean for easy check if a passive scalar systems shall be solved or not.
Definition: SIMPLESolveBase.h:163
Moose::PetscSupport::addPetscFlagsToPetscOptions
void addPetscFlagsToPetscOptions(const MultiMooseEnum &petsc_flags, const std::string &prefix, const ParallelParamObject &param_object, PetscOptions &petsc_options)
SIMPLESolveBase::_solid_energy_absolute_tolerance
const Real _solid_energy_absolute_tolerance
The user-defined absolute tolerance for determining the convergence in solid energy.
Definition: SIMPLESolveBase.h:223
SIMPLESolveBase::_solid_energy_linear_control
SIMPLESolverConfiguration _solid_energy_linear_control
Options for the linear solver of the energy equation.
Definition: SIMPLESolveBase.h:151
SIMPLESolveBase::_continue_on_max_its
const bool _continue_on_max_its
If solve should continue if maximum number of iterations is hit.
Definition: SIMPLESolveBase.h:235
SIMPLESolveBase::_turbulence_field_min_limit
std::vector< Real > _turbulence_field_min_limit
The user-defined lower limit for turbulent quantities e.g. k, eps/omega, etc..
Definition: SIMPLESolveBase.h:199
SIMPLESolveBase::_turbulence_absolute_tolerance
const std::vector< Real > _turbulence_absolute_tolerance
The user-defined absolute tolerance for determining the convergence turbulence variables.
Definition: SIMPLESolveBase.h:229
SIMPLESolveBase::_pressure_petsc_options
Moose::PetscSupport::PetscOptions _pressure_petsc_options
Options which hold the petsc settings for the pressure equation.
Definition: SIMPLESolveBase.h:110
SIMPLESolveBase::_has_solid_energy_system
const bool _has_solid_energy_system
Boolean for easy check if a solid energy system shall be solved or not.
Definition: SIMPLESolveBase.h:145
UserObjectInterface::UserObjectInterface
UserObjectInterface(const MooseObject *moose_object)

Member Function Documentation

◆ checkDependentParameterError()

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

Definition at line 606 of file SIMPLESolveBase.C.

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

609 {
610  for (const auto & param : dependent_parameters)
611  if (parameters().isParamSetByUser(param) == !should_be_defined)
612  paramError(param,
613  "This parameter should " + std::string(should_be_defined ? "" : "not") +
614  " be given by the user with the corresponding " + main_parameter +
615  " setting!");
616 }
SolveObject::paramError
void paramError(const std::string &param, Args... args) const
SolveObject::isParamSetByUser
bool isParamSetByUser(const std::string &nm) const
SolveObject::parameters
const InputParameters & parameters() const

◆ checkIntegrity()

virtual void SIMPLESolveBase::checkIntegrity ( )
inlinevirtual

Check if the user defined time kernels.

Reimplemented in SIMPLESolve, and SIMPLESolveNonlinearAssembly.

Definition at line 61 of file SIMPLESolveBase.h.

61 {}

◆ linkRhieChowUserObject()

virtual void SIMPLESolveBase::linkRhieChowUserObject ( )
pure virtual

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

Implemented in LinearAssemblySegregatedSolve, and SIMPLESolveNonlinearAssembly.

◆ setInnerSolve()

virtual void SIMPLESolveBase::setInnerSolve ( SolveObject &  )
inlineoverridevirtual

Reimplemented from SolveObject.

Definition at line 48 of file SIMPLESolveBase.h.

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

◆ setupPressurePin()

void SIMPLESolveBase::setupPressurePin ( )

Setup pressure pin if there is need for one.

Definition at line 597 of file SIMPLESolveBase.C.

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

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

◆ solveMomentumPredictor()

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

Solve a momentum predictor step with a fixed pressure field.

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

Implemented in LinearAssemblySegregatedSolve, and SIMPLESolveNonlinearAssembly.

◆ solvePressureCorrector()

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

Solve a pressure corrector step.

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

Implemented in LinearAssemblySegregatedSolve, and SIMPLESolveNonlinearAssembly.

◆ validParams()

InputParameters SIMPLESolveBase::validParams ( )
static

Definition at line 15 of file SIMPLESolveBase.C.

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

16 {
17  InputParameters params = emptyInputParameters();
18  params.addRequiredParam<UserObjectName>("rhie_chow_user_object", "The rhie-chow user-object");
19 
20  /*
21  * The names of the different systems in the segregated solver
22  */
23  params.addRequiredParam<std::vector<SolverSystemName>>(
24  "momentum_systems", "The solver system(s) for the momentum equation(s).");
25  params.addRequiredParam<SolverSystemName>("pressure_system",
26  "The solver system for the pressure equation.");
27  params.addParam<SolverSystemName>("energy_system", "The solver system for the energy equation.");
28  params.addParam<SolverSystemName>("solid_energy_system",
29  "The solver system for the solid energy equation.");
30  params.addParam<std::vector<SolverSystemName>>(
31  "passive_scalar_systems", {}, "The solver system for each scalar advection equation.");
32  params.addParam<std::vector<SolverSystemName>>(
33  "turbulence_systems", {}, "The solver system for each surrogate turbulence equation.");
34 
35  /*
36  * Parameters to control the solution of the momentum equation
37  */
38 
39  params.addRangeCheckedParam<Real>(
40  "momentum_equation_relaxation",
41  1.0,
42  "0.0<momentum_equation_relaxation<=1.0",
43  "The relaxation which should be used for the momentum equation. (=1 for no relaxation, "
44  "diagonal dominance will still be enforced)");
45 
46  params.addParam<MultiMooseEnum>("momentum_petsc_options",
47  Moose::PetscSupport::getCommonPetscFlags(),
48  "Singleton PETSc options for the momentum equation");
49  params.addParam<MultiMooseEnum>("momentum_petsc_options_iname",
50  Moose::PetscSupport::getCommonPetscKeys(),
51  "Names of PETSc name/value pairs for the momentum equation");
52  params.addParam<std::vector<std::string>>(
53  "momentum_petsc_options_value",
54  "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
55  "momentum equation");
56 
57  params.addRangeCheckedParam<Real>(
58  "momentum_absolute_tolerance",
59  1e-5,
60  "0.0<momentum_absolute_tolerance",
61  "The absolute tolerance on the normalized residual of the momentum equation.");
62 
63  params.addRangeCheckedParam<Real>("momentum_l_tol",
64  1e-5,
65  "0.0<=momentum_l_tol & momentum_l_tol<1.0",
66  "The relative tolerance on the normalized residual in the "
67  "linear solver of the momentum equation.");
68  params.addRangeCheckedParam<Real>("momentum_l_abs_tol",
69  1e-50,
70  "0.0<momentum_l_abs_tol",
71  "The absolute tolerance on the normalized residual in the "
72  "linear solver of the momentum equation.");
73  params.addParam<unsigned int>(
74  "momentum_l_max_its",
75  10000,
76  "The maximum allowed iterations in the linear solver of the momentum equation.");
77 
78  params.addParamNamesToGroup(
79  "momentum_equation_relaxation momentum_petsc_options momentum_petsc_options_iname "
80  "momentum_petsc_options_value momentum_petsc_options_value momentum_absolute_tolerance "
81  "momentum_l_tol momentum_l_abs_tol momentum_l_max_its momentum_systems",
82  "Momentum Equation");
83 
84  /*
85  * Parameters to control the solution of the pressure equation
86  */
87  params.addRangeCheckedParam<Real>(
88  "pressure_variable_relaxation",
89  1.0,
90  "0.0<pressure_variable_relaxation<=1.0",
91  "The relaxation which should be used for the pressure variable (=1 for no relaxation).");
92 
93  params.addParam<MultiMooseEnum>("pressure_petsc_options",
94  Moose::PetscSupport::getCommonPetscFlags(),
95  "Singleton PETSc options for the pressure equation");
96  params.addParam<MultiMooseEnum>("pressure_petsc_options_iname",
97  Moose::PetscSupport::getCommonPetscKeys(),
98  "Names of PETSc name/value pairs for the pressure equation");
99  params.addParam<std::vector<std::string>>(
100  "pressure_petsc_options_value",
101  "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
102  "pressure equation");
103 
104  params.addRangeCheckedParam<Real>(
105  "pressure_absolute_tolerance",
106  1e-5,
107  "0.0<pressure_absolute_tolerance",
108  "The absolute tolerance on the normalized residual of the pressure equation.");
109 
110  params.addRangeCheckedParam<Real>("pressure_l_tol",
111  1e-5,
112  "0.0<=pressure_l_tol & pressure_l_tol<1.0",
113  "The relative tolerance on the normalized residual in the "
114  "linear solver of the pressure equation.");
115  params.addRangeCheckedParam<Real>("pressure_l_abs_tol",
116  1e-10,
117  "0.0<pressure_l_abs_tol",
118  "The absolute tolerance on the normalized residual in the "
119  "linear solver of the pressure equation.");
120  params.addParam<unsigned int>(
121  "pressure_l_max_its",
122  10000,
123  "The maximum allowed iterations in the linear solver of the pressure equation.");
124 
125  params.addParamNamesToGroup(
126  "pressure_variable_relaxation pressure_petsc_options pressure_petsc_options_iname "
127  "pressure_petsc_options_value pressure_petsc_options_value pressure_absolute_tolerance "
128  "pressure_l_tol pressure_l_abs_tol pressure_l_max_its pressure_system",
129  "Pressure Equation");
130 
131  /*
132  * Pressure pin parameters for enclosed flows
133  */
134 
135  params.addParam<bool>(
136  "pin_pressure", false, "If the pressure field needs to be pinned at a point.");
137  params.addParam<Real>(
138  "pressure_pin_value", 0.0, "The value which needs to be enforced for the pressure.");
139  params.addParam<Point>("pressure_pin_point", "The point where the pressure needs to be pinned.");
140 
141  params.addParamNamesToGroup("pin_pressure pressure_pin_value pressure_pin_point", "Pressure Pin");
142 
143  params.addParam<bool>(
144  "print_fields",
145  false,
146  "Use this to print the coupling and solution fields and matrices throughout the iteration.");
147 
148  /*
149  * Parameters to control the solution of the energy equation
150  */
151 
152  params.addRangeCheckedParam<Real>(
153  "energy_equation_relaxation",
154  1.0,
155  "0.0<energy_equation_relaxation<=1.0",
156  "The relaxation which should be used for the energy equation. (=1 for no relaxation, "
157  "diagonal dominance will still be enforced)");
158 
159  params.addParam<MultiMooseEnum>("energy_petsc_options",
160  Moose::PetscSupport::getCommonPetscFlags(),
161  "Singleton PETSc options for the energy equation");
162  params.addParam<MultiMooseEnum>("energy_petsc_options_iname",
163  Moose::PetscSupport::getCommonPetscKeys(),
164  "Names of PETSc name/value pairs for the energy equation");
165  params.addParam<std::vector<std::string>>(
166  "energy_petsc_options_value",
167  "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
168  "energy equation");
169 
170  params.addRangeCheckedParam<Real>(
171  "energy_absolute_tolerance",
172  1e-5,
173  "0.0<energy_absolute_tolerance",
174  "The absolute tolerance on the normalized residual of the energy equation.");
175 
176  params.addRangeCheckedParam<Real>("energy_l_tol",
177  1e-5,
178  "0.0<=energy_l_tol & energy_l_tol<1.0",
179  "The relative tolerance on the normalized residual in the "
180  "linear solver of the energy equation.");
181  params.addRangeCheckedParam<Real>("energy_l_abs_tol",
182  1e-10,
183  "0.0<energy_l_abs_tol",
184  "The absolute tolerance on the normalized residual in the "
185  "linear solver of the energy equation.");
186  params.addRangeCheckedParam<unsigned int>(
187  "energy_l_max_its",
188  10000,
189  "0<energy_l_max_its",
190  "The maximum allowed iterations in the linear solver of the energy equation.");
191 
192  params.addParamNamesToGroup(
193  "energy_equation_relaxation energy_petsc_options energy_petsc_options_iname "
194  "energy_petsc_options_value energy_petsc_options_value energy_absolute_tolerance "
195  "energy_l_tol energy_l_abs_tol energy_l_max_its",
196  "Energy Equation");
197 
198  /*
199  * Parameters to control the solution of the solid energy equation
200  */
201 
202  params.addParam<MultiMooseEnum>("solid_energy_petsc_options",
203  Moose::PetscSupport::getCommonPetscFlags(),
204  "Singleton PETSc options for the solid energy equation");
205  params.addParam<MultiMooseEnum>("solid_energy_petsc_options_iname",
206  Moose::PetscSupport::getCommonPetscKeys(),
207  "Names of PETSc name/value pairs for the solid energy equation");
208  params.addParam<std::vector<std::string>>(
209  "solid_energy_petsc_options_value",
210  "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
211  "solid energy equation");
212 
213  params.addRangeCheckedParam<Real>(
214  "solid_energy_absolute_tolerance",
215  1e-5,
216  "0.0<solid_energy_absolute_tolerance",
217  "The absolute tolerance on the normalized residual of the solid energy equation.");
218 
219  params.addRangeCheckedParam<Real>("solid_energy_l_tol",
220  1e-5,
221  "0.0<=solid_energy_l_tol & solid_energy_l_tol<1.0",
222  "The relative tolerance on the normalized residual in the "
223  "linear solver of the solid energy equation.");
224 
225  params.addRangeCheckedParam<Real>("solid_energy_l_abs_tol",
226  1e-10,
227  "0.0<solid_energy_l_abs_tol",
228  "The absolute tolerance on the normalized residual in the "
229  "linear solver of the solid energy equation.");
230  params.addRangeCheckedParam<unsigned int>(
231  "solid_energy_l_max_its",
232  10000,
233  "0<solid_energy_l_max_its",
234  "The maximum allowed iterations in the linear solver of the solid energy equation.");
235 
236  params.addParamNamesToGroup("solid_energy_petsc_options solid_energy_petsc_options_iname "
237  "solid_energy_petsc_options_value solid_energy_absolute_tolerance "
238  "solid_energy_l_tol solid_energy_l_abs_tol solid_energy_l_max_its",
239  "Solid Energy Equation");
240 
241  /*
242  * Parameters to control the solution of each scalar advection system
243  */
244  params.addParam<std::vector<Real>>("passive_scalar_equation_relaxation",
245  std::vector<Real>(),
246  "The relaxation which should be used for the passive scalar "
247  "equations. (=1 for no relaxation, "
248  "diagonal dominance will still be enforced)");
249 
250  params.addParam<MultiMooseEnum>("passive_scalar_petsc_options",
251  Moose::PetscSupport::getCommonPetscFlags(),
252  "Singleton PETSc options for the passive scalar equation(s)");
253  params.addParam<MultiMooseEnum>(
254  "passive_scalar_petsc_options_iname",
255  Moose::PetscSupport::getCommonPetscKeys(),
256  "Names of PETSc name/value pairs for the passive scalar equation(s)");
257  params.addParam<std::vector<std::string>>(
258  "passive_scalar_petsc_options_value",
259  "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
260  "passive scalar equation(s)");
261  params.addParam<std::vector<Real>>(
262  "passive_scalar_absolute_tolerance",
263  std::vector<Real>(),
264  "The absolute tolerance(s) on the normalized residual(s) of the passive scalar equation(s).");
265  params.addRangeCheckedParam<Real>("passive_scalar_l_tol",
266  1e-5,
267  "0.0<=passive_scalar_l_tol & passive_scalar_l_tol<1.0",
268  "The relative tolerance on the normalized residual in the "
269  "linear solver of the passive scalar equation(s).");
270  params.addRangeCheckedParam<Real>("passive_scalar_l_abs_tol",
271  1e-10,
272  "0.0<passive_scalar_l_abs_tol",
273  "The absolute tolerance on the normalized residual in the "
274  "linear solver of the passive scalar equation(s).");
275  params.addParam<unsigned int>(
276  "passive_scalar_l_max_its",
277  10000,
278  "The maximum allowed iterations in the linear solver of the turbulence equation.");
279 
280  params.addParamNamesToGroup(
281  "passive_scalar_systems passive_scalar_equation_relaxation passive_scalar_petsc_options "
282  "passive_scalar_petsc_options_iname "
283  "passive_scalar_petsc_options_value passive_scalar_petsc_options_value "
284  "passive_scalar_absolute_tolerance "
285  "passive_scalar_l_tol passive_scalar_l_abs_tol passive_scalar_l_max_its",
286  "passive_scalar Equation");
287 
288  /*
289  * Parameters to control the solution of each turbulence system
290  */
291  params.addParam<std::vector<Real>>("turbulence_equation_relaxation",
292  std::vector<Real>(),
293  "The relaxation which should be used for the turbulence "
294  "equations. (=1 for no relaxation, "
295  "diagonal dominance will still be enforced)");
296 
297  params.addParam<std::vector<Real>>("turbulence_field_relaxation",
298  std::vector<Real>(),
299  "The relaxation which should be used for the turbulence "
300  "fields.");
301 
302  params.addParam<std::vector<Real>>(
303  "turbulence_field_min_limit",
304  std::vector<Real>(),
305  "The lower limit imposed on turbulent quantities. The recommended value for robustness "
306  "is 1e-8. This is the imposed default if not set.");
307 
308  params.addParam<MultiMooseEnum>("turbulence_petsc_options",
309  Moose::PetscSupport::getCommonPetscFlags(),
310  "Singleton PETSc options for the turbulence equation(s)");
311  params.addParam<MultiMooseEnum>("turbulence_petsc_options_iname",
312  Moose::PetscSupport::getCommonPetscKeys(),
313  "Names of PETSc name/value pairs for the turbulence equation(s)");
314  params.addParam<std::vector<std::string>>(
315  "turbulence_petsc_options_value",
316  "Values of PETSc name/value pairs (must correspond with \"petsc_options_iname\" for the "
317  "turbulence equation(s)");
318  params.addParam<std::vector<Real>>(
319  "turbulence_absolute_tolerance",
320  std::vector<Real>(),
321  "The absolute tolerance(s) on the normalized residual(s) of the turbulence equation(s).");
322  params.addRangeCheckedParam<Real>("turbulence_l_tol",
323  1e-5,
324  "0.0<=turbulence_l_tol & turbulence_l_tol<1.0",
325  "The relative tolerance on the normalized residual in the "
326  "linear solver of the turbulence equation(s).");
327  params.addRangeCheckedParam<Real>("turbulence_l_abs_tol",
328  1e-10,
329  "0.0<turbulence_l_abs_tol",
330  "The absolute tolerance on the normalized residual in the "
331  "linear solver of the turbulence equation(s).");
332  params.addParam<unsigned int>(
333  "turbulence_l_max_its",
334  10000,
335  "The maximum allowed iterations in the linear solver of the turbulence equation.");
336 
337  params.addParamNamesToGroup("turbulence_systems "
338  "turbulence_equation_relaxation "
339  "turbulence_field_relaxation "
340  "turbulence_field_min_limit "
341  "turbulence_petsc_options "
342  "turbulence_petsc_options_iname "
343  "turbulence_petsc_options_value turbulence_petsc_options_value "
344  "turbulence_absolute_tolerance "
345  "turbulence_l_tol turbulence_l_abs_tol turbulence_l_max_its",
346  "Turbulence Equations");
347 
348  /*
349  * SIMPLE iteration control
350  */
351 
352  params.addRangeCheckedParam<unsigned int>(
353  "num_iterations",
354  1000,
355  "0<num_iterations",
356  "The number of momentum-pressure-(other fields) iterations needed.");
357 
358  params.addParam<bool>("continue_on_max_its",
359  false,
360  "If solve should continue if maximum number of iterations is hit.");
361 
362  return params;
363 }
Moose::PetscSupport::getCommonPetscKeys
MultiMooseEnum getCommonPetscKeys()
InputParameters::addParam
void addParam(const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
InputParameters::addRequiredParam
void addRequiredParam(const std::string &name, const std::string &doc_string)
emptyInputParameters
InputParameters emptyInputParameters()
Moose::PetscSupport::getCommonPetscFlags
MultiMooseEnum getCommonPetscFlags()
Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
InputParameters::addRangeCheckedParam
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
InputParameters::addParamNamesToGroup
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)

Member Data Documentation

◆ _continue_on_max_its

const bool SIMPLESolveBase::_continue_on_max_its
protected

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

Definition at line 235 of file SIMPLESolveBase.h.

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

◆ _energy_absolute_tolerance

const Real SIMPLESolveBase::_energy_absolute_tolerance
protected

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

Definition at line 220 of file SIMPLESolveBase.h.

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

◆ _energy_equation_relaxation

const Real SIMPLESolveBase::_energy_equation_relaxation
protected

The user-defined relaxation parameter for the energy equation.

Definition at line 130 of file SIMPLESolveBase.h.

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

◆ _energy_l_abs_tol

const Real SIMPLESolveBase::_energy_l_abs_tol
protected

Absolute linear tolerance for the energy equations.

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

Definition at line 140 of file SIMPLESolveBase.h.

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

◆ _energy_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_energy_linear_control
protected

Options for the linear solver of the energy equation.

Definition at line 136 of file SIMPLESolveBase.h.

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

◆ _energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_energy_petsc_options
protected

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

Definition at line 133 of file SIMPLESolveBase.h.

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

◆ _has_energy_system

const bool SIMPLESolveBase::_has_energy_system
protected

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

Definition at line 127 of file SIMPLESolveBase.h.

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

◆ _has_passive_scalar_systems

const bool SIMPLESolveBase::_has_passive_scalar_systems
protected

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

Definition at line 163 of file SIMPLESolveBase.h.

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

◆ _has_solid_energy_system

const bool SIMPLESolveBase::_has_solid_energy_system
protected

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

Definition at line 145 of file SIMPLESolveBase.h.

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

◆ _has_turbulence_systems

const bool SIMPLESolveBase::_has_turbulence_systems
protected

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

Definition at line 187 of file SIMPLESolveBase.h.

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

◆ _momentum_absolute_tolerance

const Real SIMPLESolveBase::_momentum_absolute_tolerance
protected

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

Definition at line 214 of file SIMPLESolveBase.h.

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

◆ _momentum_equation_relaxation

const Real SIMPLESolveBase::_momentum_equation_relaxation
protected

The user-defined relaxation parameter for the momentum equation.

Definition at line 95 of file SIMPLESolveBase.h.

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

◆ _momentum_l_abs_tol

const Real SIMPLESolveBase::_momentum_l_abs_tol
protected

Absolute linear tolerance for the momentum equation(s).

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

Definition at line 89 of file SIMPLESolveBase.h.

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

◆ _momentum_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_momentum_linear_control
protected

Options for the linear solver of the momentum equation.

Definition at line 85 of file SIMPLESolveBase.h.

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

◆ _momentum_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_momentum_petsc_options
protected

Options which hold the petsc settings for the momentum equation.

Definition at line 92 of file SIMPLESolveBase.h.

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

◆ _momentum_system_names

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

The names of the momentum systems.

Definition at line 82 of file SIMPLESolveBase.h.

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

◆ _num_iterations

const unsigned int SIMPLESolveBase::_num_iterations
protected

The maximum number of momentum-pressure iterations.

Definition at line 232 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_absolute_tolerance

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

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

Definition at line 226 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_equation_relaxation

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

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

Definition at line 169 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_l_abs_tol

const Real SIMPLESolveBase::_passive_scalar_l_abs_tol
protected

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

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

Definition at line 179 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_passive_scalar_linear_control
protected

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

Definition at line 175 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_passive_scalar_petsc_options
protected

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

Definition at line 172 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_system_names

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

The names of the passive scalar systems.

Definition at line 160 of file SIMPLESolveBase.h.

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

◆ _passive_scalar_system_numbers

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

Definition at line 166 of file SIMPLESolveBase.h.

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

◆ _pin_pressure

const bool SIMPLESolveBase::_pin_pressure
protected

If the pressure needs to be pinned.

Definition at line 116 of file SIMPLESolveBase.h.

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

◆ _pressure_absolute_tolerance

const Real SIMPLESolveBase::_pressure_absolute_tolerance
protected

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

Definition at line 217 of file SIMPLESolveBase.h.

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

◆ _pressure_l_abs_tol

const Real SIMPLESolveBase::_pressure_l_abs_tol
protected

Absolute linear tolerance for the pressure equation.

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

Definition at line 107 of file SIMPLESolveBase.h.

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

◆ _pressure_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_pressure_linear_control
protected

Options for the linear solver of the pressure equation.

Definition at line 103 of file SIMPLESolveBase.h.

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

◆ _pressure_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_pressure_petsc_options
protected

Options which hold the petsc settings for the pressure equation.

Definition at line 110 of file SIMPLESolveBase.h.

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

◆ _pressure_pin_dof

dof_id_type SIMPLESolveBase::_pressure_pin_dof
protected

The dof ID where the pressure needs to be pinned.

Definition at line 122 of file SIMPLESolveBase.h.

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

◆ _pressure_pin_value

const Real SIMPLESolveBase::_pressure_pin_value
protected

The value we want to enforce for pressure.

Definition at line 119 of file SIMPLESolveBase.h.

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

◆ _pressure_system_name

const SolverSystemName& SIMPLESolveBase::_pressure_system_name
protected

The name of the pressure system.

Definition at line 100 of file SIMPLESolveBase.h.

◆ _pressure_variable_relaxation

const Real SIMPLESolveBase::_pressure_variable_relaxation
protected

The user-defined relaxation parameter for the pressure variable.

Definition at line 113 of file SIMPLESolveBase.h.

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

◆ _print_fields

const bool SIMPLESolveBase::_print_fields
protected

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

Definition at line 240 of file SIMPLESolveBase.h.

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

◆ _solid_energy_absolute_tolerance

const Real SIMPLESolveBase::_solid_energy_absolute_tolerance
protected

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

Definition at line 223 of file SIMPLESolveBase.h.

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

◆ _solid_energy_l_abs_tol

const Real SIMPLESolveBase::_solid_energy_l_abs_tol
protected

Absolute linear tolerance for the energy equations.

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

Definition at line 155 of file SIMPLESolveBase.h.

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

◆ _solid_energy_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_solid_energy_linear_control
protected

Options for the linear solver of the energy equation.

Definition at line 151 of file SIMPLESolveBase.h.

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

◆ _solid_energy_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_solid_energy_petsc_options
protected

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

Definition at line 148 of file SIMPLESolveBase.h.

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

◆ _turbulence_absolute_tolerance

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

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

Definition at line 229 of file SIMPLESolveBase.h.

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

◆ _turbulence_equation_relaxation

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

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

Definition at line 193 of file SIMPLESolveBase.h.

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

◆ _turbulence_field_min_limit

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

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

Definition at line 199 of file SIMPLESolveBase.h.

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

◆ _turbulence_field_relaxation

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

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

Definition at line 196 of file SIMPLESolveBase.h.

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

◆ _turbulence_l_abs_tol

const Real SIMPLESolveBase::_turbulence_l_abs_tol
protected

Absolute linear tolerance for the turbulence equation(s).

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

Definition at line 209 of file SIMPLESolveBase.h.

Referenced by LinearAssemblySegregatedSolve::solve().

◆ _turbulence_linear_control

SIMPLESolverConfiguration SIMPLESolveBase::_turbulence_linear_control
protected

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

Definition at line 205 of file SIMPLESolveBase.h.

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

◆ _turbulence_petsc_options

Moose::PetscSupport::PetscOptions SIMPLESolveBase::_turbulence_petsc_options
protected

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

Definition at line 202 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_names

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

The names of the turbulence systems.

Definition at line 184 of file SIMPLESolveBase.h.

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

◆ _turbulence_system_numbers

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

Definition at line 190 of file SIMPLESolveBase.h.

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

The documentation for this class was generated from the following files:
Generated on Wed Aug 6 2025 14:45:19 for https://mooseframework.inl.gov by   doxygen 1.8.14