Uses a reference residual to define relative convergence criteria. More...

#include <ReferenceResidualConvergence.h>

Inheritance diagram for ReferenceResidualConvergence:

Classes
class	ReferenceVectorTagIDKey

Public Types
enum class	MooseConvergenceStatus { ITERATING = 0 , CONVERGED = 1 , DIVERGED = -1 }
	Status returned by calls to `checkConvergence`. More...

using	IterationType = MooseEnumItem
	Iteration type.

using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name.

Public Member Functions
	ReferenceResidualConvergence (const InputParameters &parameters)

void	updateReferenceResidual ()
	Computes the reference residuals for each group.

virtual void	initialSetup () override
	Gets called at the beginning of the simulation before this object is asked to do its job.

TagID	referenceVectorTagID (ReferenceVectorTagIDKey) const
	Returns the tag ID associated with the reference vector tag ID key.

virtual void	checkIterationType (IterationType it_type) const override
	Perform checks related to the iteration type.

virtual void	preLoop () override
	Method that gets called before each iteration loop.

virtual MooseConvergenceStatus	checkConvergence (unsigned int n_iter) override
	Returns convergence status.

void	setMaximumIterations (const unsigned int max_iter)
	Sets the maximum nonlinear iterations.

void	setAbsoluteTolerance (const Real abs_tol)
	Sets the absolute nonlinear tolerance.

void	setRelativeTolerance (const Real rel_tol)
	Sets the relative nonlinear tolerance.

virtual void	preIteration ()
	Method that gets called before each iteration in a loop that this convergence object is checking.

bool	verbose () const
	Returns whether verbose mode has been enabled.

virtual bool	enabled () const
	Return the enabled status of the object.

std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group.

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

bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with.

const std::string &	type () const
	Get the type of this class.

const std::string &	name () const
	Get the name of the class.

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling.

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

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const
	Get the parameters of the object.

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object.

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object.

template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object.

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object.

template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller.

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid.

bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default.

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

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

std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

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

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError().

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type.

template<typename... Args>
void	mooseWarning (Args &&... args) const

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning().

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const

template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.

template<typename... Args>
void	mooseDeprecated (Args &&... args) const

template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.

template<typename... Args>
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
	External method for calling moose error with added object context.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Deprecated method.

std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method.

std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path.

virtual void	timestepSetup ()
	Gets called at the beginning of the timestep before this object is asked to do its job.

virtual void	jacobianSetup ()
	Gets called just before the Jacobian is computed and before this object is asked to do its job.

virtual void	residualSetup ()
	Gets called just before the residual is computed and before this object is asked to do its job.

virtual void	subdomainSetup ()
	Gets called when the subdomain changes (i.e.

virtual void	customSetup (const ExecFlagType &)
	Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain.

const ExecFlagEnum &	getExecuteOnEnum () const
	Return the execute on MultiMooseEnum for this object.

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	Determine whether or not the Postprocessor is a default value.

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const
	Determine if the Postprocessor data exists.

bool	hasPostprocessorByName (const PostprocessorName &name) const
	Determine if the Postprocessor data exists.

std::size_t	coupledPostprocessors (const std::string &param_name) const
	Returns number of Postprocessors coupled under parameter name.

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const
	Get the name of a postprocessor.

PerfGraph &	perfGraph ()
	Get the PerfGraph.

bool	isImplicit ()

Moose::StateArg	determineState () const
	Create a functor state argument that corresponds to the implicit state of this object.

template<typename T >
void	addGroupVariables (const std::set< T > &group_vars)
	Add a set of variables that need to be grouped together.


const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values

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


virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const
	Retrieve the value of the Postprocessor.

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

Static Public Member Functions
static InputParameters	validParams ()

static InputParameters	residualConvergenceParams ()

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)
	External method for calling moose error with added object context.

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Static Public Attributes
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.

static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.

static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.

static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.

static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.

static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

Protected Types
enum class	ZeroReferenceType { ZERO_TOLERANCE , RELATIVE_TOLERANCE }
	Container for convergence treatment when the reference residual is zero. More...

Protected Member Functions
virtual NonlinearSystemBase &	nonlinearSystem () override
	Nonlinear system whose convergence state should be checked.

virtual void	nonlinearConvergenceSetup () override
	Performs setup necessary for each call to checkConvergence.

virtual bool	checkResidualConvergence (const unsigned int n_iter, const Real fnorm, const Real ref_norm, const Real rel_tol, const Real abs_tol, std::ostringstream &oss) override
	Check the absolute and relative convergence of the nonlinear solution.

bool	checkConvergenceIndividVars (const Real fnorm, const Real abs_tol, const Real rel_tol, const Real initial_residual_before_preset_bcs)
	Check the convergence by comparing the norm of each variable's residual separately against its reference variable's norm.

void	setNonlinearSystemParameters ()
	Sets the nonlinear system parameters, such as tolerances.

void	checkPetscToleranceOverrides ()
	Warns, once per simulation, if any PETSc SNES tolerance/iteration options (e.g.

template<typename T >
const T &	getSharedExecutionerParam (const std::string &name)
	This method is to be used for parameters that are shared with the executioner.

void	checkDuplicateSetSharedExecutionerParams () const
	Throws an error if any of the parameters shared with the executioner have been set by the user in both places.

void	verboseOutput (std::ostringstream &oss)
	Outputs the stream to the console if verbose output is enabled.

template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID.

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

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const
	Helper for deriving classes to override to add dependencies when a Postprocessor is requested.

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.

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

Protected Attributes
const MooseEnum	_norm_type_enum
	Enum holding the normalization type.

const unsigned int	_nl_sys_num
	Nonlinear system to which this convergence object applies.

std::vector< bool >	_is_var_grouped
	Vector of bools to signify if variable is in a group.

std::vector< unsigned int >	_group_index
	Group number index for each variable.

std::vector< Real >	_scaling_factors
	Local storage for the scaling factors applied to each of the variables to apply to _ref_resid_vars.

const NumericVector< Number > *	_residual_vector
	The optional vector storing the reference residual values.

const NumericVector< Number > *	_reference_vector
	The vector storing the reference residual values.

std::vector< bool >	_converge_on_var
	Flag for each solution variable or group being in 'converge_on'.

std::vector< bool >	_converge_on_group

enum ReferenceResidualConvergence::ZeroReferenceType	_zero_ref_type

const bool	_unscale_the_residual
	Bool to unscale the residual before convergence checks and screen output.

bool	_local_norm
	Flag to optionally perform normalization of residual by reference residual before or after L2 norm is computed.

libMesh::FEMNormType	_norm_type
	Container for normalization type.

TagID	_reference_vector_tag_id
	The reference vector tag id.

FEProblemBase &	_fe_problem

const Real	_nl_abs_div_tol
	Nonlinear absolute divergence tolerance.

const Real	_nl_rel_div_tol
	Nonlinear relative divergence tolerance.

const Real	_div_threshold
	Divergence threshold value.

unsigned int	_nl_forced_its
	Number of iterations to force.

const unsigned int	_nl_max_pingpong
	Maximum number of nonlinear ping-pong iterations for a solve.

unsigned int	_nl_current_pingpong
	Current number of nonlinear ping-pong iterations for the current solve.

const Real	_nl_rel_step_tol
	Nonlinear relative step tolerance.

const unsigned int	_nl_max_funcs
	Maximum number of residual (function) evaluations.

unsigned int	_nl_max_its
	Nonlinear maximum nonlinear iterations (modifiable by setMaximumIterations)

Real	_nl_abs_tol
	Nonlinear absolute tolerance (modifiable by setAbsoluteTolerance)

Real	_nl_rel_tol
	Nonlinear relative tolerance (modifiable by setRelativeTolerance)

PerfID	_perfid_check_convergence
	Performance ID for `checkConvergence`.

THREAD_ID	_tid
	Thread ID.

const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

MooseApp &	_app
	The MOOSE application this is associated with.

Factory &	_factory
	The Factory associated with the MooseApp.

ActionFactory &	_action_factory
	Builds Actions.

const std::string &	_type
	The type of this class.

const std::string &	_name
	The name of this class.

const InputParameters &	_pars
	The object's parameters.

const Parallel::Communicator &	_communicator

const ExecFlagEnum &	_execute_enum
	Execute settings for this object.

const ExecFlagType &	_current_execute_flag
	Reference to FEProblemBase.

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.

const std::string	_prefix
	A prefix to use for all sections.

const InputParameters &	_ti_params

FEProblemBase &	_ti_feproblem

bool	_is_implicit
	If the object is using implicit or explicit form.

Real &	_t
	Time.

const Real &	_t_old
	Old time.

int &	_t_step
	The number of the time step.

Real &	_dt
	Time step size.

Real &	_dt_old
	Size of the old time step.

bool	_is_transient

std::vector< std::vector< NonlinearVariableName > >	_group_variables
	Name of variables that are grouped together to check convergence.

bool	_use_group_variables
	True if any variables are grouped.


std::vector< NonlinearVariableName >	_soln_var_names

std::vector< AuxVariableName >	_ref_resid_var_names


std::vector< NonlinearVariableName >	_group_names


std::vector< unsigned int >	_soln_vars

std::vector< unsigned int >	_ref_resid_vars


const Real	_accept_mult

const unsigned int	_accept_iters


std::vector< Real >	_group_ref_resid

std::vector< Real >	_group_resid

Private Member Functions
const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const
	Internal method for getting the PostprocessorName associated with a paremeter.

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const
	Checks the parameters relating to a Postprocessor.

bool	postprocessorsAdded () const


const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const
	Internal methods for getting Postprocessor values.

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

Private Attributes
bool	_nl_checked_petsc_tolerance_overrides = false
	Whether checkPetscToleranceOverrides() has already run for this simulation.

const bool	_added_as_default
	True if this object was added as a default instead of by the user.

std::vector< std::string >	_duplicate_shared_executioner_params
	List of shared executioner parameters that have been set by the user in both places.

const bool	_verbose
	Verbose mode enabled.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

ExecFlagEnum	_empty_execute_enum
	Empty ExecFlagEnum for the case when the "execute_on" parameter is not included.

const MooseObject &	_ppi_moose_object
	The MooseObject that uses this interface.

const InputParameters &	_ppi_params
	PostprocessorInterface Parameters.

const FEProblemBase &	_ppi_feproblem
	Reference the the FEProblemBase class.

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values
	Holds the default postprocessor values that are requested (key is PostprocessorName)

const std::string	_ti_name

Detailed Description

Uses a reference residual to define relative convergence criteria.

Definition at line 24 of file ReferenceResidualConvergence.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

◆ IterationType

using Convergence::IterationType = MooseEnumItem

inherited

Iteration type.

Definition at line 41 of file Convergence.h.

Member Enumeration Documentation

◆ MooseConvergenceStatus

enum class Convergence::MooseConvergenceStatus

stronginherited

Status returned by calls to checkConvergence.

Enumerator
ITERATING
CONVERGED
DIVERGED

Definition at line 33 of file Convergence.h.

  {
    ITERATING = 0,
    CONVERGED = 1,
    DIVERGED = -1
  };

◆ ZeroReferenceType

enum class ReferenceResidualConvergence::ZeroReferenceType

strongprotected

Container for convergence treatment when the reference residual is zero.

Enumerator
ZERO_TOLERANCE
RELATIVE_TOLERANCE

Definition at line 134 of file ReferenceResidualConvergence.h.

134{ ZERO_TOLERANCE, RELATIVE_TOLERANCE } _zero_ref_type;

ReferenceResidualConvergence::ZeroReferenceType::ZERO_TOLERANCE

@ ZERO_TOLERANCE

ReferenceResidualConvergence::ZeroReferenceType::RELATIVE_TOLERANCE

@ RELATIVE_TOLERANCE

ReferenceResidualConvergence::_zero_ref_type

enum ReferenceResidualConvergence::ZeroReferenceType _zero_ref_type

Constructor & Destructor Documentation

◆ ReferenceResidualConvergence()

ReferenceResidualConvergence::ReferenceResidualConvergence ( const InputParameters & parameters )

Definition at line 36 of file ReferenceResidualConvergence.C.

  : DefaultNonlinearConvergence(parameters),
    ReferenceResidualInterface(this),
    _norm_type_enum(getParam<MooseEnum>("normalization_type")),
    _accept_mult(getParam<Real>("acceptable_multiplier")),
    _accept_iters(getParam<unsigned int>("acceptable_iterations")),
    _nl_sys_num(_fe_problem.solverSysNum(getParam<SolverSystemName>("solver_sys"))),
    _residual_vector(nullptr),
    _reference_vector(nullptr),
    _zero_ref_type(
        getParam<MooseEnum>("zero_reference_residual_treatment").getEnum<ZeroReferenceType>()),
    _unscale_the_residual(getParam<bool>("unscale_the_residual")),
    _reference_vector_tag_id(Moose::INVALID_TAG_ID)
{
  if (_fe_problem.numNonlinearSystems() > 1 && !isParamSetByUser("solver_sys"))
    paramError("solver_sys",
               "Reference residual problem does not currently support multiple nonlinear systems "
               "in a single Convergence object. Multiple Convergence objects can be used, one for "
               "each nonlinear system, via the 'solver_sys' parameter.");
 
  if (parameters.isParamValid("residual_vector"))
  {
    const auto residual_vector_tag_id =
        _fe_problem.getVectorTagID(getParam<TagName>("residual_vector"));
    _residual_vector =
        &_fe_problem.getNonlinearSystemBase(_nl_sys_num).getVector(residual_vector_tag_id);
  }
  else
    _residual_vector = &_fe_problem.getNonlinearSystemBase(_nl_sys_num).RHS();
 
  if (parameters.isParamValid("reference_vector"))
  {
    _reference_vector_tag_id = _fe_problem.getVectorTagID(getParam<TagName>("reference_vector"));
    _reference_vector =
        &_fe_problem.getNonlinearSystemBase(_nl_sys_num).getVector(_reference_vector_tag_id);
  }
  else
    mooseDeprecated(
        "No `reference_vector` is provided, thus the Reference Residual convergence method will "
        "revert to default tolerance checking. `reference_vector` will become a required parameter "
        "on June 1st, 2027. If you are using `ReferenceResidualProblem`, either provide a "
        "reference_vector or use a standard problem type (e.g., remove "
        "Problem/type=ReferenceResidualProblem from your input file). If you are using "
        "`ReferenceResidualConvergence`, either provide a reference_vector or utilize "
        "`DefaultNonlinearConvergence` instead.");
 
  if (_norm_type_enum == "LOCAL_L2")
  {
    _norm_type = libMesh::DISCRETE_L2;
    _local_norm = true;
  }
  else if (_norm_type_enum == "GLOBAL_L2")
  {
    _norm_type = libMesh::DISCRETE_L2;
    _local_norm = false;
  }
  else if (_norm_type_enum == "LOCAL_LINF")
  {
    _norm_type = libMesh::DISCRETE_L_INF;
    _local_norm = true;
  }
  else if (_norm_type_enum == "GLOBAL_LINF")
  {
    _norm_type = libMesh::DISCRETE_L_INF;
    _local_norm = false;
  }
  else
    mooseAssert(false, "This point should not be reached.");
 
  if (_local_norm && !parameters.isParamValid("reference_vector"))
    paramError("reference_vector", "If local norm is used, a reference_vector must be provided.");
}

Member Function Documentation

◆ addGroupVariables()

template<typename T >

void ReferenceResidualInterface::addGroupVariables ( const std::set< T > & group_vars )

inherited

Add a set of variables that need to be grouped together.

For use in actions that create variables. This is templated for backwards compatibility to allow passing in std::string or NonlinearVariableName.

Template Parameters

T	string type used for variable names

Parameters

group_vars A set of solution variables that need to be grouped.

Definition at line 48 of file ReferenceResidualInterface.h.

{
  _group_variables.push_back(
      std::vector<NonlinearVariableName>(group_vars.begin(), group_vars.end()));
  _use_group_variables = true;
}

◆ addPostprocessorDependencyHelper()

virtual void PostprocessorInterface::addPostprocessorDependencyHelper ( const PostprocessorName & ) const

inlineprotectedvirtualinherited

Helper for deriving classes to override to add dependencies when a Postprocessor is requested.

Reimplemented in UserObjectBase, AuxKernelBase, and InitialConditionBase.

Definition at line 149 of file PostprocessorInterface.h.

149{}

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal().

◆ callMooseError() [1/2]

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

staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);
 
  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }
 
  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;
 
  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
}

◆ callMooseError() [2/2]

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

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

{
  callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
}

Referenced by MooseBase::callMooseError(), InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

◆ checkConvergence()

Convergence::MooseConvergenceStatus DefaultNonlinearConvergence::checkConvergence ( unsigned int n_iter )

overridevirtualinherited

Returns convergence status.

Parameters

[in] n_iter Number of iterations performed; For example, it should equal 1 for the check after the first iteration. Note that some iteration types (e.g., nonlinear) can make a check before the first iteration, in which case this should be 0.

Implements Convergence.

Definition at line 184 of file DefaultNonlinearConvergence.C.

{
  TIME_SECTION(_perfid_check_convergence);
 
  NonlinearSystemBase & system = nonlinearSystem();
  MooseConvergenceStatus status = MooseConvergenceStatus::ITERATING;
 
  SNES snes = system.getSNES();
 
  checkPetscToleranceOverrides();
 
  // ||u||
  PetscReal xnorm;
  LibmeshPetscCallA(_fe_problem.comm().get(), SNESGetSolutionNorm(snes, &xnorm));
 
  // ||r||
  PetscReal fnorm;
  LibmeshPetscCallA(_fe_problem.comm().get(), SNESGetFunctionNorm(snes, &fnorm));
 
  // ||du||
  PetscReal snorm;
  LibmeshPetscCallA(_fe_problem.comm().get(), SNESGetUpdateNorm(snes, &snorm));
 
  // Get current number of function evaluations done by SNES
  PetscInt nfuncs;
  LibmeshPetscCallA(_fe_problem.comm().get(), SNESGetNumberFunctionEvals(snes, &nfuncs));
 
#if !PETSC_VERSION_LESS_THAN(3, 8, 4)
  PetscBool force_iteration = PETSC_FALSE;
  LibmeshPetscCallA(_fe_problem.comm().get(), SNESGetForceIteration(snes, &force_iteration));
 
  // if PETSc says to force iteration, then force at least one iteration
  if (force_iteration && !(_nl_forced_its))
    _nl_forced_its = 1;
 
  // if specified here to force iteration, but PETSc doesn't know, tell it
  if (!force_iteration && (_nl_forced_its))
  {
    LibmeshPetscCallA(_fe_problem.comm().get(), SNESSetForceIteration(snes, PETSC_TRUE));
  }
#endif
 
  // See if SNESSetFunctionDomainError() has been called.
  // Note: SNESSetFunctionDomainError() and SNESGetFunctionDomainError() were added
  // in different releases of PETSc. The latter was removed in PETSc 3.25.0.
#if PETSC_VERSION_LESS_THAN(3, 25, 0)
  PetscBool domainerror;
  LibmeshPetscCallA(_fe_problem.comm().get(), SNESGetFunctionDomainError(snes, &domainerror));
  if (domainerror)
    status = MooseConvergenceStatus::DIVERGED;
#else
  SNESConvergedReason reason;
  LibmeshPetscCallA(_fe_problem.comm().get(), SNESGetConvergedReason(snes, &reason));
  if (reason == SNES_DIVERGED_FUNCTION_DOMAIN)
    status = MooseConvergenceStatus::DIVERGED;
#endif
 
  // Needed by ResidualReferenceConvergence
  nonlinearConvergenceSetup();
 
  Real fnorm_old;
  // This is the first residual before any iterations have been done, but after
  // solution-modifying objects (if any) have been imposed on the solution vector.
  // We save it, and use it to detect convergence if system.usePreSMOResidual() == false.
  if (n_iter == 0)
  {
    system.setInitialResidual(fnorm);
    fnorm_old = fnorm;
    _nl_current_pingpong = 0;
  }
  else
    fnorm_old = system._last_nl_rnorm;
 
  // Check for nonlinear residual ping-pong.
  // Ping-pong will always start from a residual increase
  if ((_nl_current_pingpong % 2 == 1 && !(fnorm > fnorm_old)) ||
      (_nl_current_pingpong % 2 == 0 && fnorm > fnorm_old))
    _nl_current_pingpong += 1;
  else
    _nl_current_pingpong = 0;
 
  const auto ref_residual = system.referenceResidual();
  std::ostringstream oss;
  if (n_iter < _nl_forced_its)
    oss << "Number of forced iterations not yet reached: " << n_iter << " < " << _nl_forced_its
        << '\n';
  else if (fnorm != fnorm)
  {
    oss << "Failed to converge, residual norm is NaN\n";
    status = MooseConvergenceStatus::DIVERGED;
  }
  else if (checkResidualConvergence(n_iter, fnorm, ref_residual, _nl_rel_tol, _nl_abs_tol, oss))
    status = MooseConvergenceStatus::CONVERGED;
  else if (nfuncs >= cast_int<PetscInt>(_nl_max_funcs))
  {
    oss << "Exceeded maximum number of residual evaluations: " << nfuncs << " > " << _nl_max_funcs
        << '\n';
    status = MooseConvergenceStatus::DIVERGED;
  }
  else if ((n_iter >= _nl_forced_its) && n_iter && fnorm > system._last_nl_rnorm &&
           fnorm >= _div_threshold)
  {
    oss << "Nonlinear solve was blowing up!\n";
    status = MooseConvergenceStatus::DIVERGED;
  }
  else if (snorm < _nl_rel_step_tol * xnorm)
  {
    oss << "Converged due to small update length: " << snorm << " < " << _nl_rel_step_tol << " * "
        << xnorm << '\n';
    status = MooseConvergenceStatus::CONVERGED;
  }
  else if (_nl_rel_div_tol > 0 && fnorm > ref_residual * _nl_rel_div_tol)
  {
    oss << "Diverged due to relative residual " << ref_residual << " > divergence tolerance "
        << _nl_rel_div_tol << " * relative residual " << ref_residual << '\n';
    status = MooseConvergenceStatus::DIVERGED;
  }
  else if (_nl_abs_div_tol > 0 && fnorm > _nl_abs_div_tol)
  {
    oss << "Diverged due to residual " << fnorm << " > absolute divergence tolerance "
        << _nl_abs_div_tol << '\n';
    status = MooseConvergenceStatus::DIVERGED;
  }
  else if (_nl_current_pingpong > _nl_max_pingpong)
  {
    oss << "Diverged due to maximum nonlinear residual pingpong achieved" << '\n';
    status = MooseConvergenceStatus::DIVERGED;
  }
 
  system._last_nl_rnorm = fnorm;
  system._current_nl_its = static_cast<unsigned int>(n_iter);
 
  std::string msg;
  msg = oss.str();
  if (_app.multiAppLevel() > 0)
    MooseUtils::indentMessage(_app.name(), msg);
  if (msg.length() > 0)
#if !PETSC_VERSION_LESS_THAN(3, 17, 0)
    LibmeshPetscCallA(_fe_problem.comm().get(), PetscInfo(snes, "%s", msg.c_str()));
#else
    LibmeshPetscCallA(_fe_problem.comm().get(), PetscInfo(snes, msg.c_str()));
#endif
 
  verboseOutput(oss);
 
  return status;
}

◆ checkConvergenceIndividVars()

bool ReferenceResidualConvergence::checkConvergenceIndividVars	(	const Real	fnorm,
		const Real	abs_tol,
		const Real	rel_tol,
		const Real	initial_residual_before_preset_bcs
	)

protected

Check the convergence by comparing the norm of each variable's residual separately against its reference variable's norm.

Only consider the solution converged if all variables are converged individually using either a relative or absolute criterion.

Parameters

fnorm	Function norm (norm of full residual vector)
abs_tol	Absolute convergence tolerance
rel_tol	Relative convergence tolerance
initial_residual_before_preset_bcs	Initial norm of full residual vector before applying preset bcs

Returns: true if all variables are converged

Definition at line 409 of file ReferenceResidualConvergence.C.

{
  // Convergence is checked via:
  // 1) Ratio of group residual to reference is less than relative tolerance
  // 2) if group residual is less than absolute tolerance
  // 3) if group reference residual is zero and:
  //   3.1) Convergence type is ZERO_TOLERANCE and group residual is zero (rare, but possible, and
  //        historically implemented that way)
  //   3.2) Convergence type is RELATIVE_TOLERANCE and group residual
  //        is less than relative tolerance. (i.e., using the relative tolerance to check group
  //        convergence in an absolute way)
 
  bool convergedRelative = true;
  for (const auto i : index_range(_group_resid))
    convergedRelative &=
        ((!_local_norm && _group_resid[i] < _group_ref_resid[i] * rel_tol) ||
         (_local_norm && _group_ref_resid[i] < rel_tol) || _group_resid[i] < abs_tol ||
         (!_group_ref_resid[i] && !_local_norm &&
          ((_zero_ref_type == ZeroReferenceType::ZERO_TOLERANCE && !_group_resid[i]) ||
           (_zero_ref_type == ZeroReferenceType::RELATIVE_TOLERANCE &&
            _group_resid[i] <= rel_tol))));
  return convergedRelative;
}

Referenced by checkResidualConvergence().

◆ checkDuplicateSetSharedExecutionerParams()

void DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams ( ) const

protectedinherited

Throws an error if any of the parameters shared with the executioner have been set by the user in both places.

This should be called after all calls to getSharedExecutionerParam. No error is thrown if the Convergence object was added as a default, since in that case, any parameters set by the user in the executioner will also be considered set by the user in the Convergence.

Definition at line 33 of file DefaultConvergenceBase.C.

{
  if (_duplicate_shared_executioner_params.size() > 0 && !_added_as_default)
  {
    std::ostringstream oss;
    oss << "The following parameters were set in both this Convergence object and the "
           "executioner:\n";
    for (const auto & param : _duplicate_shared_executioner_params)
      oss << "  " << param << "\n";
    mooseError(oss.str());
  }
}

Referenced by DefaultConvergenceBase::initialSetup().

◆ checkIterationType()

void DefaultNonlinearConvergence::checkIterationType ( IterationType ) const

overridevirtualinherited

Perform checks related to the iteration type.

Reimplemented from Convergence.

Definition at line 70 of file DefaultNonlinearConvergence.C.

{
  DefaultConvergenceBase::checkIterationType(it_type);
 
  if (it_type != ConvergenceIterationTypes::NONLINEAR)
    mooseError("DefaultNonlinearConvergence can only be used with nonlinear solves.");
}

◆ checkParam()

void PostprocessorInterface::checkParam	(	const std::string &	param_name,
		const unsigned int	index = `std::numeric_limits<unsigned int>::max()`
	)		const

privateinherited

Checks the parameters relating to a Postprocessor.

If index is not set, index checking is not performed.

Definition at line 149 of file PostprocessorInterface.C.

{
  const bool check_index = index != std::numeric_limits<unsigned int>::max();
 
  if (!_ppi_params.isParamValid(param_name))
    _ppi_moose_object.mooseError(
        "When getting a Postprocessor, failed to get a parameter with the name \"",
        param_name,
        "\".",
        "\n\nKnown parameters:\n",
        _ppi_moose_object.parameters());
 
  if (_ppi_params.isType<PostprocessorName>(param_name))
  {
    if (check_index && index > 0)
      _ppi_moose_object.paramError(param_name,
                                   "A Postprocessor was requested with index ",
                                   index,
                                   " but a single Postprocessor is coupled.");
  }
  else if (_ppi_params.isType<std::vector<PostprocessorName>>(param_name))
  {
    const auto & names = _ppi_params.get<std::vector<PostprocessorName>>(param_name);
    if (check_index && names.size() <= index)
      _ppi_moose_object.paramError(param_name,
                                   "A Postprocessor was requested with index ",
                                   index,
                                   " but only ",
                                   names.size(),
                                   " Postprocessors are coupled.");
  }
  else
  {
    _ppi_moose_object.mooseError(
        "Supplied parameter with name \"",
        param_name,
        "\" of type \"",
        _ppi_params.type(param_name),
        "\" is not an expected type for getting a Postprocessor.\n\n",
        "Allowed types are \"PostprocessorName\" and \"std::vector<PostprocessorName>\".");
  }
}

Referenced by PostprocessorInterface::coupledPostprocessors(), and PostprocessorInterface::getPostprocessorNameInternal().

◆ checkPetscToleranceOverrides()

void DefaultNonlinearConvergence::checkPetscToleranceOverrides ( )

protectedinherited

Warns, once per simulation, if any PETSc SNES tolerance/iteration options (e.g.

-snes_rtol) were set to a value different from what this object caches and enforces, since such PETSc-level settings are otherwise silently ignored by this object's own convergence check.

Definition at line 140 of file DefaultNonlinearConvergence.C.

{
  if (_nl_checked_petsc_tolerance_overrides)
    return;
  _nl_checked_petsc_tolerance_overrides = true;
 
  NonlinearSystemBase & nl_sys = nonlinearSystem();
  auto & params = nl_sys.system().parameters;
  // If another DefaultNonlinearConvergence object last wrote these shared parameters (as
  // happens when multiple such objects are combined, e.g. via ParsedConvergence, onto the same
  // nonlinear system), its tolerances are the ones actually active on the SNES, not ours; that
  // is not a PETSc command-line override, so there is nothing for us to warn about here.
  if (params.get<const DefaultNonlinearConvergence *>(
          "_default_nonlinear_convergence_tolerance_writer") != this)
    return;
 
  SNES snes = nl_sys.getSNES();
  PetscReal abs_tol, rel_tol, rel_step_tol;
  PetscInt max_its, max_funcs;
  LibmeshPetscCallA(
      _fe_problem.comm().get(),
      SNESGetTolerances(snes, &abs_tol, &rel_tol, &rel_step_tol, &max_its, &max_funcs));
 
  std::ostringstream oss;
  if (abs_tol != _nl_abs_tol)
    oss << "  -snes_atol = " << abs_tol << " (nl_abs_tol = " << _nl_abs_tol << ")\n";
  if (rel_tol != _nl_rel_tol)
    oss << "  -snes_rtol = " << rel_tol << " (nl_rel_tol = " << _nl_rel_tol << ")\n";
  if (rel_step_tol != _nl_rel_step_tol)
    oss << "  -snes_stol = " << rel_step_tol << " (nl_rel_step_tol = " << _nl_rel_step_tol << ")\n";
  if (max_its != static_cast<PetscInt>(_nl_max_its))
    oss << "  -snes_max_it = " << max_its << " (nl_max_its = " << _nl_max_its << ")\n";
  if (max_funcs != static_cast<PetscInt>(_nl_max_funcs))
    oss << "  -snes_max_funcs = " << max_funcs << " (nl_max_funcs = " << _nl_max_funcs << ")\n";
 
  if (!oss.str().empty())
    mooseWarning("The following PETSc SNES option(s) were set to a value different from what "
                 "this Convergence object enforces. Because this object performs its own "
                 "convergence check using its own cached tolerances, these PETSc-level settings "
                 "have no effect:\n",
                 oss.str());
}

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ checkResidualConvergence()

bool ReferenceResidualConvergence::checkResidualConvergence	(	const unsigned int	n_iter,
		const Real	fnorm,
		const Real	ref_norm,
		const Real	rel_tol,
		const Real	abs_tol,
		std::ostringstream &	oss
	)

overrideprotectedvirtual

Check the absolute and relative convergence of the nonlinear solution.

Parameters

n_iter	Number of iterations performed
fnorm	Norm of the residual vector
ref_norm	Norm to use for reference value
rel_tol	Relative tolerance
abs_tol	Absolute tolerance
oss	Output streamstring

Returns: Bool signifying convergence

Reimplemented from DefaultNonlinearConvergence.

Definition at line 438 of file ReferenceResidualConvergence.C.

{
  // If no refernce_vector is provided, just revert to DefaultNonlinearConvergence behavior
  if (!_reference_vector)
    return DefaultNonlinearConvergence::checkResidualConvergence(
        n_iter, fnorm, ref_norm, rel_tol, abs_tol, oss);
 
  if (checkConvergenceIndividVars(fnorm, abs_tol, rel_tol, ref_norm))
  {
    oss << "Converged normally";
    return true;
  }
  else if (n_iter >= _accept_iters &&
           checkConvergenceIndividVars(
               fnorm, abs_tol * _accept_mult, rel_tol * _accept_mult, ref_norm))
  {
    oss << "  Converged due a larger acceptable tolerance due to `acceptible_multiplier` after "
           "`acceptible_iterations`.";
    _console << "  Converged due to ACCEPTABLE tolerances" << std::endl;
    return true;
  }
 
  return false;
}

◆ connectControllableParams()

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

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 77 of file MooseBase.C.

{
  auto & factory = _app.getFactory();
  auto & ip_warehouse = _app.getInputParameterWarehouse();
 
  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = factory.getValidParams(object_type).getBase();
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
 
  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
  for (const auto & tag : tags)
  {
    if (!tag.empty())
    {
      // Only adds the parameter with the different control tags if the derived class
      // properly registers the parameter to its own syntax
      MooseObjectParameterName tagged_name(tag, name(), parameter);
      ip_warehouse.addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

◆ coupledPostprocessors()

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

inherited

Returns number of Postprocessors coupled under parameter name.

Parameters

param_name The name of the Postprocessor parameter

Returns: Number of coupled post-processors, 1 if it's a single

Definition at line 139 of file PostprocessorInterface.C.

{
  checkParam(param_name);
 
  if (_ppi_params.isType<PostprocessorName>(param_name))
    return 1;
  return _ppi_params.get<std::vector<PostprocessorName>>(param_name).size();
}

Referenced by FunctionValuePostprocessor::FunctionValuePostprocessor().

◆ customSetup()

virtual void SetupInterface::customSetup ( const ExecFlagType & )

inlinevirtualinherited

Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain.

Reimplemented in Function.

Definition at line 69 of file SetupInterface.h.

69{}

◆ determineState()

Moose::StateArg TransientInterface::determineState ( ) const

inlineinherited

Create a functor state argument that corresponds to the implicit state of this object.

If we are implicit then we will return the current state. If we are not, then we will return the old state

Definition at line 92 of file TransientInterface.h.

{
  return _is_implicit ? Moose::currentState() : Moose::oldState();
}

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition MooseObject.h:71

Referenced by EigenKernel::enabled(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and NodeFaceConstraint::validParams().

◆ errorPrefix()

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

inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ flagInvalidSolutionInternal()

template<bool warning>

template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID invalid_solution_id ) const

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

{
  mooseAssert(
      warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
      "Inconsistent warning flag");
  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
  if constexpr (!warning)
    if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
      solution_invalidity.printDebug(invalid_solution_id);
  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
}

◆ getBase()

const std::string & MooseBase::getBase ( ) const

inlineinherited

Returns: The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by MooseBase::uniqueParameterName().

◆ getCheckedPointerParam()

template<typename T >

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

inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 450 of file MooseBase.h.

{
  return _pars.getCheckedPointerParam<T>(name, error_string);
}

◆ getDataFileName()

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

inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
                          "within the InputParameters.\nUse getParam<DataFileName>(\"",
                          param,
                          "\") instead.");
  return _parent.getParam<DataFileName>(param);
}

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                          relative_path,
                          "\") instead.");
  return getDataFilePath(relative_path);
}

◆ getDataFilePath()

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

inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");
 
  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }
 
  if (error)
    _parent.mooseError(*error);
 
  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");
 
  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);
 
  return found_path.path;
}

Referenced by DataFileInterface::getDataFileNameByName().

◆ getDefaultPostprocessorValueByName()

PostprocessorValue PostprocessorInterface::getDefaultPostprocessorValueByName ( const PostprocessorName & name ) const

privateinherited

Returns: The default value stored in the PostprocessorName name.

Definition at line 106 of file PostprocessorInterface.C.

{
  mooseAssert(isDefaultPostprocessorValueByName(name), "Not a default value");
 
  Real real_value = -std::numeric_limits<Real>::max();
  std::istringstream ss(name);
  ss >> real_value;
  return real_value;
}

Referenced by PostprocessorInterface::getPostprocessorValueInternal().

◆ getExecuteOnEnum()

const ExecFlagEnum & SetupInterface::getExecuteOnEnum ( ) const

inherited

Return the execute on MultiMooseEnum for this object.

Definition at line 73 of file SetupInterface.C.

{
  return _execute_enum;
}

Referenced by ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), MultiAppTransfer::checkMultiAppExecuteOn(), Control::Control(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), Terminator::initialSetup(), MultiAppTransfer::MultiAppTransfer(), Exodus::outputSetup(), ElementReporter::shouldStore(), GeneralReporter::shouldStore(), NodalReporter::shouldStore(), and PIDTransientControl::timestepSetup().

◆ getHitNode() [1/2]

const hit::Node * MooseBase::getHitNode ( ) const

inlineinherited

Returns: The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

Referenced by MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

◆ getHitNode() [2/2]

const hit::Node * MooseBase::getHitNode ( const InputParameters & params )

staticprivateinherited

Internal method for getting a hit node (if available) given a set of parameters.

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 167 of file MooseBase.C.

{
  if (const auto hit_node = params.getHitNode())
    if (!hit_node->isRoot())
      return hit_node;
  return nullptr;
}

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), MooseMesh::cacheChangedLists(), ReporterTransferInterface::checkHasReporterValue(), LinearFVGradientManager::checkRestartedGradientHistory(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), GreaterThanLessThanPostprocessor::execute(), Terminator::execute(), WorkBalance::execute(), FEProblemSolve::FEProblemSolve(), RadialAverage::finalize(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), SubProblem::numThreads(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), AuxiliarySystem::registerFVGradient(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

◆ getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

{
  return InputParameters::getParamHelper<T>(name, _pars);
}

Referenced by CommonOutputAction::act(), CreateDisplacedProblemAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), Console::Console(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DiffusionPhysicsBase::DiffusionPhysicsBase(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), SurfaceDelaunayGeneratorBase::fillDelaunayOptions(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), ParsedSubdomainGeneratorBase::functionInitialize(), BlockDeletionGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FileMeshGenerator::generate(), MeshExtruderGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), AdvancedOutput::init(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), AdvancedOutput::initAvailableLists(), AttribThread::initFrom(), AttribExecutionOrderGroup::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), ReferenceResidualInterface::ReferenceResidualInterface(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), PetscOutput::solveSetup(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorOfPostprocessors::VectorOfPostprocessors(), and XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters

param1	The name of first parameter
param2	The name of second parameter

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

{
  return _pars.get<T1, T2>(param1, param2);
}

◆ getPostprocessorName()

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

inherited

Get the name of a postprocessor.

This can only be used if the postprocessor parameter does not have a default value set (see isDefaultPostprocessorValue()), in which case the "name" is actually the default value.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns: The name of the given Postprocessor

Definition at line 195 of file PostprocessorInterface.C.

{
  return getPostprocessorNameInternal(param_name, index, /* allow_default_value = */ false);
}

Referenced by EigenKernel::EigenKernel().

◆ getPostprocessorNameInternal()

const PostprocessorName & PostprocessorInterface::getPostprocessorNameInternal	(	const std::string &	param_name,
		const unsigned int	index,
		const bool	allow_default_value = `true`
	)		const

privateinherited

Internal method for getting the PostprocessorName associated with a paremeter.

Needed in order to allow the return of a name that is a default value.

Definition at line 202 of file PostprocessorInterface.C.

{
  checkParam(param_name, index);
 
  const auto & name = _ppi_params.isType<PostprocessorName>(param_name)
                          ? _ppi_params.get<PostprocessorName>(param_name)
                          : _ppi_params.get<std::vector<PostprocessorName>>(param_name)[index];
 
  if (!allow_default_value && isDefaultPostprocessorValueByName(name))
  {
    std::stringstream oss;
    oss << "Cannot get the name associated with PostprocessorName parameter \"" << param_name
        << "\"";
    if (index)
      oss << " at index " << index;
    oss << ",\nbecause said parameter is a default Postprocessor value.";
    _ppi_moose_object.paramError(param_name, oss.str());
  }
 
  return name;
}

Referenced by PostprocessorInterface::getPostprocessorName(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), and PostprocessorInterface::isDefaultPostprocessorValue().

◆ getPostprocessorValue()

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

inherited

doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values

Parameters

param_name	The name of the Postprocessor parameter (see below)
index	The index of the Postprocessor

Returns: A reference to the desired value

The name required by this method is the name that is hard-coded into your source code. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this function requires the "pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValueByName getPostprocessorValueOldByName getPostprocessorValueOlderByName

Definition at line 46 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 0);
}

Referenced by EigenKernel::EigenKernel(), FunctionValuePostprocessor::FunctionValuePostprocessor(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), and ParsedPostprocessor::ParsedPostprocessor().

◆ getPostprocessorValueByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueByName ( const PostprocessorName & name ) const

virtualinherited

Retrieve the value of the Postprocessor.

Parameters

name	Postprocessor name (see below)

Returns: A reference to the desired value

The name required by this method is the name defined in the input file. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this method requires the "my_pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValue getPostprocessorValueOld getPostprocessorValueOlder

Definition at line 67 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 0);
}

Referenced by EigenKernel::EigenKernel(), PIDTransientControl::execute(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), ParsedODEKernel::ParsedODEKernel(), PicardSolve::savePostprocessorValues(), SecantSolve::savePostprocessorValues(), SteffensenSolve::savePostprocessorValues(), SumPostprocessor::SumPostprocessor(), Terminator::Terminator(), PicardSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), and VectorOfPostprocessors::VectorOfPostprocessors().

◆ getPostprocessorValueByNameInternal()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueByNameInternal	(	const PostprocessorName &	name,
		std::size_t	t_index
	)		const

privateinherited

Definition at line 256 of file PostprocessorInterface.C.

{
  mooseAssert(t_index < 3, "Invalid time index");
  mooseAssert(!isDefaultPostprocessorValueByName(name), "Should not be default");
 
  // If all pps have been added, we can check for existance
  if (postprocessorsAdded() && !hasPostprocessorByName(name))
    _ppi_moose_object.mooseError("A Postprocessor with the name \"", name, "\" was not found.");
 
  if (t_index == 0)
    addPostprocessorDependencyHelper(name);
 
  return _ppi_feproblem.getReporterData().getReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name), _ppi_moose_object, REPORTER_MODE_ROOT, t_index);
}

Referenced by PostprocessorInterface::getPostprocessorValueByName(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::getPostprocessorValueOldByName(), and PostprocessorInterface::getPostprocessorValueOlderByName().

◆ getPostprocessorValueInternal()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueInternal	(	const std::string &	param_name,
		unsigned int	index,
		std::size_t	t_index
	)		const

privateinherited

Internal methods for getting Postprocessor values.

Definition at line 228 of file PostprocessorInterface.C.

{
  const auto & name = getPostprocessorNameInternal(param_name, index);
 
  // If the Postprocessor is a default value (either set by addParam or set to a constant
  // value by the user in input/an action), we covert the name to a value, store said
  // value locally, and return it so that it fits in with the rest of the interface
  // (needing a reference to a value)
  if (isDefaultPostprocessorValueByName(name))
  {
    const auto value = getDefaultPostprocessorValueByName(name);
    const auto & value_ref =
        *_default_values.emplace(name, std::make_unique<PostprocessorValue>(value))
             .first->second; // first is inserted pair, second is value in pair
    mooseAssert(value == value_ref, "Inconsistent default value");
    return value_ref;
  }
  // If not a default and all pps have been added, we check check for existance
  else if (postprocessorsAdded() && !hasPostprocessorByName(name))
    _ppi_moose_object.paramError(
        param_name, "A Postprocessor with the name \"", name, "\" was not found.");
 
  return getPostprocessorValueByNameInternal(name, t_index);
}

Referenced by PostprocessorInterface::getPostprocessorValue(), PostprocessorInterface::getPostprocessorValueOld(), and PostprocessorInterface::getPostprocessorValueOlder().

◆ getPostprocessorValueOld()

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

inherited

Definition at line 53 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 1);
}

◆ getPostprocessorValueOldByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOldByName ( const PostprocessorName & name ) const

inherited

Definition at line 73 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 1);
}

Referenced by EigenKernel::EigenKernel().

◆ getPostprocessorValueOlder()

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

inherited

Definition at line 60 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 2);
}

◆ getPostprocessorValueOlderByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlderByName ( const PostprocessorName & name ) const

inherited

Definition at line 79 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 2);
}

◆ getRenamedParam()

template<typename T >

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

inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 420 of file MooseBase.h.

{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

◆ getSharedExecutionerParam()

template<typename T >

const T & DefaultConvergenceBase::getSharedExecutionerParam ( const std::string & name )

protectedinherited

This method is to be used for parameters that are shared with the executioner.

If the parameter is set by the user in the executioner, get that value; otherwise, get this object's value. If the parameter is set by the user in both this object and the executioner, add it to a list and report an error later.

Definition at line 60 of file DefaultConvergenceBase.h.

{
  const auto * executioner = getMooseApp().getExecutioner();
  if (executioner->isParamSetByUser(param))
  {
    if (isParamSetByUser(param))
      _duplicate_shared_executioner_params.push_back(param);
    return executioner->getParam<T>(param);
  }
  else
    return getParam<T>(param);
}

◆ getSharedPtr() [1/2]

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

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

Referenced by MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), and WebServerControl::addServerAction().

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 83 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns: Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ hasPostprocessor()

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

inherited

Determine if the Postprocessor data exists.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns: True if the Postprocessor exists

See also: hasPostprocessorByName getPostprocessorValue

Definition at line 117 of file PostprocessorInterface.C.

{
  if (!postprocessorsAdded())
    _ppi_moose_object.mooseError(
        "Cannot call hasPostprocessor() until all Postprocessors have been constructed.");
 
  return hasPostprocessorByName(getPostprocessorNameInternal(param_name, index));
}

◆ hasPostprocessorByName()

bool PostprocessorInterface::hasPostprocessorByName ( const PostprocessorName & name ) const

inherited

Determine if the Postprocessor data exists.

Parameters

name	The name of the Postprocessor

Returns: True if the Postprocessor exists

See also: hasPostprocessor getPostprocessorValueByName

Definition at line 128 of file PostprocessorInterface.C.

{
  if (!postprocessorsAdded())
    _ppi_moose_object.mooseError(
        "Cannot call hasPostprocessorByName() until all Postprocessors have been constructed.");
 
  return _ppi_feproblem.getReporterData().hasReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name));
}

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), AdvancedOutput::initShowHideLists(), Exodus::outputReporters(), and TableOutput::outputReporters().

◆ initialSetup()

void ReferenceResidualConvergence::initialSetup ( )

overridevirtual

Gets called at the beginning of the simulation before this object is asked to do its job.

Reimplemented from DefaultNonlinearConvergence.

Definition at line 116 of file ReferenceResidualConvergence.C.

{
  DefaultNonlinearConvergence::initialSetup();
  // If no refernce_vector is provided, just revert to DefaultNonlinearConvergence behavior
  if (!_reference_vector)
    return;
 
  auto & nonlinear_sys = nonlinearSystem();
  auto & s = nonlinear_sys.system();
 
  // If the user provides reference_vector, that implies that they want the
  // individual variables compared against their reference quantities in the
  // tag vector. The code depends on having _soln_var_names populated,
  // so fill that out if they didn't specify solution_variables.
  for (const auto var_num : make_range(s.n_vars()))
    _soln_var_names.push_back(s.variable_name(var_num));
  const auto n_soln_vars = nonlinear_sys.nVariables();
 
  const auto converge_on = getParam<std::vector<NonlinearVariableName>>("converge_on");
  if (!converge_on.empty())
  {
    _converge_on_var.assign(n_soln_vars, false);
    for (std::size_t i = 0; i < n_soln_vars; ++i)
      for (const auto & c : converge_on)
        if (MooseUtils::globCompare(_soln_var_names[i], c))
        {
          _converge_on_var[i] = true;
          break;
        }
  }
  else
    _converge_on_var.assign(n_soln_vars, true);
 
  unsigned int num_variables_in_groups = 0;
  for (const auto i : index_range(_group_variables))
  {
    num_variables_in_groups += _group_variables[i].size();
    if (_group_variables[i].size() == 1)
      paramError("group_variables",
                 "variable ",
                 _group_variables[i][0],
                 " is not grouped with other variables.");
  }
 
  // If no groups, size = n_soln_vars
  unsigned int n_groups = n_soln_vars - num_variables_in_groups + _group_variables.size();
  _group_ref_resid.resize(n_groups);
  _group_resid.resize(n_groups);
  _group_names.resize(n_groups);
  _converge_on_group.assign(n_groups, true);
  _scaling_factors.resize(n_soln_vars);
 
  // Check to make sure variables aren't in multiple groups
  if (_use_group_variables)
  {
    std::set<std::string> check_duplicate;
    for (const auto i : index_range(_group_variables))
      for (const auto j : index_range(_group_variables[i]))
        check_duplicate.insert(_group_variables[i][j]);
 
    if (check_duplicate.size() != num_variables_in_groups)
      paramError("group_variables", "A variable cannot be included in multiple groups.");
  }
 
  _soln_vars.clear();
  for (const auto i : make_range(n_soln_vars))
  {
    bool found_match = false;
    for (const auto var_num : make_range(s.n_vars()))
      if (_soln_var_names[i] == s.variable_name(var_num))
      {
        _soln_vars.push_back(var_num);
        found_match = true;
        break;
      }
 
    if (!found_match)
      mooseError("Could not find solution variable '",
                 _soln_var_names[i],
                 "' in system '",
                 s.name(),
                 "'.");
  }
 
  unsigned int ungroup_index = 0;
  if (_use_group_variables)
    ungroup_index = _group_variables.size();
 
  // Determine which group each variable belongs to
  _group_index.resize(n_soln_vars);
  _is_var_grouped.assign(n_soln_vars, false);
  for (const auto i : index_range(_soln_vars))
  {
    if (_use_group_variables)
    {
      for (const auto j : index_range(_group_variables))
        if (std::find(_group_variables[j].begin(),
                      _group_variables[j].end(),
                      s.variable_name(_soln_vars[i])) != _group_variables[j].end())
        {
          if (!_converge_on_var[i])
            paramError("converge_on",
                       "You added variable '",
                       _soln_var_names[i],
                       "' to a group but excluded it from the convergence check. This is not "
                       "permitted.");
 
          _group_index[i] = j;
          _is_var_grouped[i] = true;
          break;
        }
 
      if (!_is_var_grouped[i])
      {
        _group_index[i] = ungroup_index;
        ungroup_index++;
      }
    }
    else
      _group_index[i] = i;
  }
 
  // Check for variable groups containing both field and scalar variables
  for (const auto i : index_range(_group_variables))
  {
    unsigned int num_scalar_vars = 0;
    unsigned int num_field_vars = 0;
    if (_group_variables[i].size() > 1)
    {
      for (const auto j : index_range(_group_variables[i]))
        for (const auto var_num : make_range(s.n_vars()))
          if (_group_variables[i][j] == s.variable_name(var_num))
          {
            if (nonlinear_sys.isScalarVariable(_soln_vars[var_num]))
              ++num_scalar_vars;
            else
              ++num_field_vars;
            break;
          }
    }
    if (num_scalar_vars > 0 && num_field_vars > 0)
      paramWarning("group_variables",
                   "standard variables and scalar variables are grouped together in group ",
                   i);
  }
 
  for (const auto i : index_range(_group_names))
  {
    // Accumulate names for a given group
    std::vector<NonlinearVariableName> names;
    for (const auto j : index_range(_group_index))
      if (_group_index[j] == i)
      {
        names.push_back(_soln_var_names[j]);
        _converge_on_group[i] = _converge_on_group[i] && _converge_on_var[j];
      }
    if (names.size() == 0)
      mooseError("Internal error, something is wrong with variable grouping");
    else if (names.size() == 1)
      _group_names[i] = names[0];
    else
    {
      _group_names[i] = "(";
      for (const auto j : index_range(names))
      {
        _group_names[i] += names[j];
        if (j != names.size() - 1)
          _group_names[i] += ", ";
      }
      _group_names[i] += ")";
    }
  }
}

◆ isDefaultPostprocessorValue()

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

inherited

Determine whether or not the Postprocessor is a default value.

A default value is when the value is either the value set by addParam, or is a user-set value in input instead of a name to a postprocessor.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the postprocessor

Returns: True if the Postprocessor is a default value, false if the Postprocessor is the name of a Postprocessor

Definition at line 85 of file PostprocessorInterface.C.

{
  return isDefaultPostprocessorValueByName(getPostprocessorNameInternal(param_name, index));
}

Referenced by EigenKernel::EigenKernel().

◆ isDefaultPostprocessorValueByName()

bool PostprocessorInterface::isDefaultPostprocessorValueByName ( const PostprocessorName & name ) const

privateinherited

Returns: True if the PostprocessorName name repesents a default value: the name converts to a value (set by addParam or set via input), and a Postprocessor does not exist with the same name (we do allow Postprocessors with numbered names...)

Definition at line 92 of file PostprocessorInterface.C.

{
  // We do allow actual Postprocessor objects to have names that will succeed in being
  // represented as a double... so if the name does actually exist as a PP, it's not a default
  if (_ppi_feproblem.getReporterData().hasReporterValue<PostprocessorValue>(
          PostprocessorReporterName(name)))
    return false;
 
  std::istringstream ss(name);
  Real real_value = -std::numeric_limits<Real>::max();
  return (ss >> real_value && ss.eof());
}

Referenced by PostprocessorInterface::getDefaultPostprocessorValueByName(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), and PostprocessorInterface::isDefaultPostprocessorValue().

◆ isImplicit()

bool TransientInterface::isImplicit ( )

inlineinherited

Definition at line 47 of file TransientInterface.h.

47{ return _is_implicit; }

Referenced by ComputeJacobianThread::compute(), ComputeJacobianThread::compute(), ComputeJacobianThread::compute(), ComputeJacobianThread::compute(), and ComputeJacobianThread::compute().

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

Definition at line 63 of file MooseObject.h.

63{ return parameters().isKokkosObject(); }

InputParameters::isKokkosObject

bool isKokkosObject() const

Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_obje...

Definition InputParameters.C:433

Referenced by AttribKokkos::initFrom(), BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

◆ isParamSetByUser()

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

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MFEMNewtonNonlinearSolver::ConstructSolver(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), MeshDiagnosticsGenerator::generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), MFEMEigenproblem::getRHSCoefficient(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), LibtorchNeuralNetControl::initialSetup(), ElementSubdomainModifierBase::initialSetup(), LibtorchNeuralNetControl::loadControlNeuralNetFromFile(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMEigenproblem::MFEMEigenproblem(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MooseApp::MooseApp(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), MooseApp::setMFEMDevice(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), MFEMHypreBoomerAMG::SetSolverParameters(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TriToQuadConverter::TriToQuadConverter(), XYFrontalDelaunayGenerator::XYFrontalDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

◆ jacobianSetup()

void SetupInterface::jacobianSetup ( )

virtualinherited

Gets called just before the Jacobian is computed and before this object is asked to do its job.

Reimplemented in DiffusionLHDGDirichletBC, DiffusionLHDGPrescribedGradientBC, ElementAndTraceScalarHDGBC, EqualValueEmbeddedConstraintTempl< is_ad >, ADDiracKernel, DiffusionLHDGKernel, ElementAndTraceScalarHDGKernel, ADArrayKernel, ADKernelTempl< T >, ADArrayNodalKernel, Positions, Times, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< Real >, MooseVariableFE< RealEigenVector >, MooseVariableFE< RealVectorValue >, MooseVariableFE< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and Function.

Definition at line 58 of file SetupInterface.C.

59{

60}

Referenced by MooseVariableField< OutputType >::jacobianSetup(), and ComputeFVFluxJacobianThread< RangeType >::setup().

◆ messagePrefix() [1/2]

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

inlineinherited

Returns: A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::messagePrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

◆ messagePrefix() [2/2]

std::string MooseBase::messagePrefix	(	const InputParameters &	params,
		const bool	hit_prefix
	)

staticprivateinherited

Internal method for getting the message prefix for an object (object type, name, etc).

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 140 of file MooseBase.C.

{
  std::string prefix = "";
 
  if (hit_prefix)
    if (const auto node = MooseBase::getHitNode(params))
      prefix += Moose::hitMessagePrefix(*node);
 
  // Don't have context without type and name
  if (!params.isMooseBaseObject())
    return prefix;
 
  const auto & name = params.getObjectName();
  const std::string base = params.hasBase() ? params.getBase() : "object";
  const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
  prefix += "The following occurred in the ";
  if (is_main_app)
    prefix += "main " + base;
  else
    prefix += base;
  if (base != params.getObjectName() && name.size() && !is_main_app)
    prefix += " '" + name + "'";
  prefix += " of type " + params.getObjectType() + ".";
  return prefix + "\n\n";
}

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 317 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by MooseApp::addCapability(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), MooseApp::MooseApp(), and MooseApp::setupOptions().

◆ mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
  }

Referenced by MultiApp::appProblem(), AddVariableAction::determineType(), MooseMesh::elem(), MooseMesh::elem(), FunctionDT::FunctionDT(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicDistance(), MooseMesh::minPeriodicVector(), MooseMesh::node(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), and MooseMesh::setBoundaryToNormalMap().

◆ mooseDeprecatedNoTrace()

template<typename... Args>

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

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 327 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, false, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by MooseApp::MooseApp().

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 277 of file MooseBase.h.

  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
  }

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 290 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
  }

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

  {
    moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), MooseApp::setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

  {
    moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by DiracKernelInfo::findPoint(), DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), MooseBase::paramWarning(), and MooseApp::setupOptions().

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

Referenced by CopyMeshPartitioner::_do_partition(), AddFunctionAction::act(), AddKernelAction::act(), CommonOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), MooseMesh::addPeriodicVariable(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkPolygons(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), BSplineCurveGenerator::generate(), RenumberBySubdomainGenerator::generate(), SubdomainPerElementGenerator::generate(), SurfaceMeshGeneratorBase::get2DElemNormal(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MFEMRefinementMarker::MFEMRefinementMarker(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), MooseMesh::setCoordSystem(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 308 of file MooseBase.h.

  {
    moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
  }

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

◆ name()

const std::string & MooseBase::name ( ) const

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

◆ nonlinearConvergenceSetup()

void ReferenceResidualConvergence::nonlinearConvergenceSetup ( )

overrideprotectedvirtual

Performs setup necessary for each call to checkConvergence.

Reimplemented from DefaultNonlinearConvergence.

Definition at line 356 of file ReferenceResidualConvergence.C.

{
  // If no refernce_vector is provided, just revert to DefaultNonlinearConvergence behavior
  if (!_reference_vector)
    return;
 
  updateReferenceResidual();
 
  std::ostringstream out;
  out << _name << ": " << _norm_type_enum << " Reference Residual check\n";
 
  if (_group_names.size() > 0)
  {
    // Set residual and references so that they always have a spacing of 8
    out << std::setprecision(2) << std::scientific;
    unsigned int var_space = 0;
    for (const auto i : index_range(_group_names))
      if (_group_names[i].size() > var_space)
        var_space = _group_names[i].size();
 
    for (const auto i : index_range(_group_names))
    {
      if (_converge_on_group[i])
      {
        // Print residual
        out << "   " << std::setw(var_space + 8) << std::right << _group_names[i] + "-> res: "
            << (_group_resid[i] < _nl_abs_tol ? COLOR_YELLOW : COLOR_DEFAULT) << std::setw(8)
            << _group_resid[i] << COLOR_DEFAULT;
 
        // Print res/ref ratio
        if (_local_norm)
          out << "  local res/ref: "
              << (_group_resid[i] / _group_ref_resid[i] < _nl_rel_tol ? COLOR_GREEN : COLOR_DEFAULT)
              << std::setw(8) << _group_ref_resid[i] << COLOR_DEFAULT << "\n";
        else
        {
          // Print reference first if not local norm
          out << "  ref: " << std::setw(8) << _group_ref_resid[i] << "  res/ref: ";
 
          if (!_group_ref_resid[i])
            out << _group_resid[i] << "\n";
          else
            out << (_group_resid[i] / _group_ref_resid[i] < _nl_rel_tol ? COLOR_GREEN
                                                                        : COLOR_DEFAULT)
                << std::setw(8) << _group_resid[i] / _group_ref_resid[i] << COLOR_DEFAULT << "\n";
        }
      }
    }
    _console << out.str() << std::flush;
  }
}

◆ nonlinearSystem()

NonlinearSystemBase & ReferenceResidualConvergence::nonlinearSystem ( )

overrideprotectedvirtual

Nonlinear system whose convergence state should be checked.

Reimplemented from DefaultNonlinearConvergence.

Definition at line 110 of file ReferenceResidualConvergence.C.

{
  return _fe_problem.getNonlinearSystemBase(_nl_sys_num);
}

Referenced by initialSetup(), and updateReferenceResidual().

◆ paramError()

template<typename... Args>

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

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 457 of file MooseBase.h.

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

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

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 471 of file MooseBase.h.

{
  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
}

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FEProblemBase::execMultiApps(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

◆ paramWarning() [1/2]

template<typename... Args>

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

inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 464 of file MooseBase.h.

{
  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
}

◆ paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), CylindricalGridDivision::CylindricalGridDivision(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), initialSetup(), SolutionIC::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), MultiAppTransfer::MultiAppTransfer(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), Terminator::Terminator(), and SolutionAux::validateVariable().

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

◆ postprocessorsAdded()

bool PostprocessorInterface::postprocessorsAdded ( ) const

privateinherited

Returns: True if all pps have been added (the task associated with adding them is complete)

Definition at line 274 of file PostprocessorInterface.C.

{
  return _ppi_feproblem.getMooseApp().actionWarehouse().isTaskComplete("add_postprocessor");
}

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), and PostprocessorInterface::hasPostprocessorByName().

◆ preIteration()

virtual void Convergence::preIteration ( )

inlinevirtualinherited

Method that gets called before each iteration in a loop that this convergence object is checking.

For example, for fixed-point convergence, this is called once per fixed-point iteration, before that iteration's sub-solve(s).

Reimplemented in DefaultMultiAppFixedPointConvergence, and ParsedConvergence.

Definition at line 60 of file Convergence.h.

60{}

Referenced by DefaultMultiAppFixedPointConvergence::preIteration(), FEProblemSolve::solve(), and FixedPointSolve::solveStep().

◆ preLoop()

void DefaultNonlinearConvergence::preLoop ( )

overridevirtualinherited

Method that gets called before each iteration loop.

Reimplemented from Convergence.

Definition at line 79 of file DefaultNonlinearConvergence.C.

{
  DefaultConvergenceBase::preLoop();
 
  setNonlinearSystemParameters();
}

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or if the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns: A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

◆ referenceVectorTagID()

TagID ReferenceResidualConvergence::referenceVectorTagID ( ReferenceVectorTagIDKey ) const

inline

Returns the tag ID associated with the reference vector tag ID key.

Definition at line 45 of file ReferenceResidualConvergence.h.

45{ return _reference_vector_tag_id; }

Referenced by TaggingInterface::TaggingInterface().

◆ registerInvalidSolutionInternal()

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

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

◆ registerTimedSection() [1/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns: The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

◆ registerTimedSection() [2/2]

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

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns: The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

◆ residualConvergenceParams()

static InputParameters DefaultNonlinearConvergence::residualConvergenceParams ( )

staticinherited

◆ residualSetup()

void SetupInterface::residualSetup ( )

virtualinherited

Gets called just before the residual is computed and before this object is asked to do its job.

Reimplemented in NodeFaceConstraint, Positions, Times, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< Real >, MooseVariableFE< RealEigenVector >, MooseVariableFE< RealVectorValue >, MooseVariableFE< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and Function.

Definition at line 63 of file SetupInterface.C.

64{

65}

Referenced by MooseVariableField< OutputType >::residualSetup(), ComputeFVFluxResidualThread< RangeType >::setup(), and ComputeFVFluxRJThread< RangeType >::setup().

◆ setAbsoluteTolerance()

void DefaultNonlinearConvergence::setAbsoluteTolerance ( const Real abs_tol )

inherited

Sets the absolute nonlinear tolerance.

Definition at line 339 of file DefaultNonlinearConvergence.C.

{
  _nl_abs_tol = abs_tol;
}

Referenced by EigenExecutionerBase::nonlinearSolve().

◆ setMaximumIterations()

void DefaultNonlinearConvergence::setMaximumIterations ( const unsigned int max_iter )

inherited

Sets the maximum nonlinear iterations.

Definition at line 333 of file DefaultNonlinearConvergence.C.

{
  _nl_max_its = max_iter;
}

Referenced by EigenExecutionerBase::inversePowerIteration().

◆ setNonlinearSystemParameters()

void DefaultNonlinearConvergence::setNonlinearSystemParameters ( )

protectedinherited

Sets the nonlinear system parameters, such as tolerances.

Definition at line 87 of file DefaultNonlinearConvergence.C.

{
  NonlinearSystemBase & nl_sys = _fe_problem.currentNonlinearSystem();
 
  auto & params = nl_sys.system().parameters;
  params.set<unsigned int>("nonlinear solver maximum iterations") = _nl_max_its;
  params.set<unsigned int>("nonlinear solver maximum function evaluations") = _nl_max_funcs;
  params.set<Real>("nonlinear solver absolute residual tolerance") = _nl_abs_tol;
  params.set<Real>("nonlinear solver relative residual tolerance") = _nl_rel_tol;
  params.set<Real>("nonlinear solver divergence tolerance") =
      getSharedExecutionerParam<Real>("nl_div_tol");
  params.set<Real>("nonlinear solver absolute step tolerance") =
      getSharedExecutionerParam<Real>("nl_abs_step_tol");
  params.set<Real>("nonlinear solver relative step tolerance") = _nl_rel_step_tol;
 
  // Records which object's tolerances are the ones actually active on the shared SNES, so that
  // checkPetscToleranceOverrides() does not mistake another DefaultNonlinearConvergence object's
  // (legitimately) overwriting these same parameters for an ignored PETSc command-line option.
  params.set<const DefaultNonlinearConvergence *>(
      "_default_nonlinear_convergence_tolerance_writer") = this;
}

Referenced by DefaultNonlinearConvergence::initialSetup(), and DefaultNonlinearConvergence::preLoop().

◆ setRelativeTolerance()

void DefaultNonlinearConvergence::setRelativeTolerance ( const Real rel_tol )

inherited

Sets the relative nonlinear tolerance.

Definition at line 345 of file DefaultNonlinearConvergence.C.

{
  _nl_rel_tol = rel_tol;
}

Referenced by EigenExecutionerBase::inversePowerIteration(), and EigenExecutionerBase::nonlinearSolve().

◆ subdomainSetup()

void SetupInterface::subdomainSetup ( )

virtualinherited

Gets called when the subdomain changes (i.e.

in a Jacobian or residual loop) and before this object is asked to do its job

Reimplemented in Material, MaterialBase, GeneralUserObject, NodalUserObject, ThreadedGeneralUserObject, Constraint, Moose::Kokkos::AuxKernel, Moose::Kokkos::MaterialBase, and Moose::Kokkos::UserObject.

Definition at line 68 of file SetupInterface.C.

69{

70}

◆ timedSectionName()

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

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? section_name : _prefix + "::" + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

◆ timestepSetup()

void SetupInterface::timestepSetup ( )

virtualinherited

Gets called at the beginning of the timestep before this object is asked to do its job.

Reimplemented in VectorPostprocessorVisualizationAux, EqualValueEmbeddedConstraintTempl< is_ad >, PIDTransientControl, Function, ElementSubdomainModifierBase, Console, JSONOutput, Positions, MemoryUsage, NumNonlinearIterations, Times, SolutionUserObjectBase, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and VectorMemoryUsage.

Definition at line 53 of file SetupInterface.C.

54{

55}

Referenced by JSONOutput::timestepSetup(), and MooseVariableField< OutputType >::timestepSetup().

◆ type()

const std::string & MooseBase::type ( ) const

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns: The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

◆ uniqueParameterName()

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

inherited

Returns: The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

◆ updateReferenceResidual()

void ReferenceResidualConvergence::updateReferenceResidual ( )

Computes the reference residuals for each group.

Definition at line 291 of file ReferenceResidualConvergence.C.

{
  // If no reference_vector is provided, this method is completely skipped
 
  auto & nonlinear_sys = nonlinearSystem();
  auto & s = nonlinear_sys.system();
 
  for (const auto i : index_range(_scaling_factors))
    if (nonlinear_sys.isScalarVariable(_soln_vars[i]))
      _scaling_factors[i] = nonlinear_sys.getScalarVariable(0, _soln_vars[i]).scalingFactor();
    else
      _scaling_factors[i] = nonlinear_sys.getVariable(/*tid*/ 0, _soln_vars[i]).scalingFactor();
 
  std::fill(_group_resid.begin(), _group_resid.end(), 0.0);
  std::fill(_group_ref_resid.begin(), _group_ref_resid.end(), 0.0);
 
  for (const auto i : index_range(_soln_vars))
  {
    if (_converge_on_var[i])
    {
      const auto group = _group_index[i];
 
      // Prepare residual
      auto resid = Utility::pow<2>(s.calculate_norm(*_residual_vector, _soln_vars[i], _norm_type));
      if (_unscale_the_residual)
      {
        mooseAssert(_scaling_factors[i], "Scaling factor must not be zero");
        resid /= Utility::pow<2>(_scaling_factors[i]);
      }
      _group_resid[group] += resid;
 
      // Prepare reference residual. If local norm, this is actually the ratio of the residual
      // dividied by the reference at all DOF
      Real ref_resid;
      if (_local_norm)
      {
        mooseAssert((*_residual_vector).size() == (*_reference_vector).size(),
                    "Sizes of nonlinear RHS and reference vector should be the same.");
        mooseAssert((*_reference_vector).size(), "Reference vector must be provided.");
        auto ref = _reference_vector->clone();
        // Add a tiny number to the reference to prevent a divide by zero.
        ref->add(std::numeric_limits<Number>::min());
        auto div = (*_residual_vector).clone();
        *div /= *ref;
        ref_resid = Utility::pow<2>(s.calculate_norm(*div, _soln_vars[i], _norm_type));
      }
      else
      {
        ref_resid =
            Utility::pow<2>(s.calculate_norm(*_reference_vector, _soln_vars[i], _norm_type));
        if (_unscale_the_residual)
          ref_resid /= Utility::pow<2>(_scaling_factors[i]);
      }
      _group_ref_resid[group] += ref_resid;
    }
  }
 
  for (const auto i : index_range(_group_resid))
  {
    _group_resid[i] = std::sqrt(_group_resid[i]);
    _group_ref_resid[i] = std::sqrt(_group_ref_resid[i]);
  }
}

Referenced by nonlinearConvergenceSetup().

◆ validParams()

InputParameters ReferenceResidualConvergence::validParams ( )

static

Definition at line 24 of file ReferenceResidualConvergence.C.

{
  InputParameters params = DefaultNonlinearConvergence::validParams();
  params += ReferenceResidualInterface::validParams();
 
  params.addClassDescription(
      "Check the convergence of a problem with respect to a user-supplied reference solution."
      " Replaces ReferenceResidualProblem, currently still used in conjunction with it.");
 
  return params;
}

◆ verbose()

bool Convergence::verbose ( ) const

inlineinherited

Returns whether verbose mode has been enabled.

Definition at line 73 of file Convergence.h.

73{ return _verbose; }

Convergence::_verbose

const bool _verbose

Verbose mode enabled.

Definition Convergence.h:89

Referenced by Convergence::verboseOutput().

◆ verboseOutput()

void Convergence::verboseOutput ( std::ostringstream & oss )

protectedinherited

Outputs the stream to the console if verbose output is enabled.

Definition at line 51 of file Convergence.C.

{
  const auto str = oss.str();
 
  if (str.length() == 0)
    return;
 
  if (verbose())
    _console << name() << ": " << str << std::endl;
}

Referenced by DefaultNonlinearConvergence::checkConvergence(), PostprocessorSteadyStateConvergence::checkConvergence(), IterationCountConvergence::checkConvergence(), MultiPostprocessorConvergence::checkConvergenceInner(), and PostprocessorConvergence::checkConvergenceInner().

Member Data Documentation

◆ _accept_iters

const unsigned int ReferenceResidualConvergence::_accept_iters

protected

Definition at line 102 of file ReferenceResidualConvergence.h.

Referenced by checkResidualConvergence().

◆ _accept_mult

const Real ReferenceResidualConvergence::_accept_mult

protected

"Acceptable" absolute and relative tolerance multiplier and acceptable number of iterations. Used when checking the convergence of individual variables.

Definition at line 101 of file ReferenceResidualConvergence.h.

Referenced by checkResidualConvergence().

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _added_as_default

const bool DefaultConvergenceBase::_added_as_default

privateinherited

True if this object was added as a default instead of by the user.

Definition at line 52 of file DefaultConvergenceBase.h.

Referenced by DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), DefaultNonlinearConvergence::checkConvergence(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), FEProblemBase::checkProblemIntegrity(), LibmeshPartitioner::clone(), BlockWeightedPartitioner::clone(), CopyMeshPartitioner::clone(), GridPartitioner::clone(), HierarchicalGridPartitioner::clone(), PetscExternalPartitioner::clone(), RandomPartitioner::clone(), SingleRankPartitioner::clone(), ElementPointNeighborLayers::clone(), ElementSideNeighborLayers::clone(), GhostAllPointNeighbors::clone(), GhostBoundary::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostLowerDElems::clone(), GhostPrimaryFace::clone(), ProxyRelationshipManager::clone(), RedistributeProperties::clone(), SampledOutput::cloneMesh(), FEProblemBase::computeJacobianSys(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualSys(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), Control::Control(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MultiApp::createApps(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), PIDTransientControl::execute(), Eigenvalue::execute(), InversePowerMethod::execute(), NonlinearEigen::execute(), SteadyBase::execute(), TransientBase::execute(), MFEMSteady::execute(), PseudoTimestep::execute(), IterationInfo::execute(), EigenProblem::execute(), Executioner::Executioner(), Executioner::Executioner(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), NEML2Assembly::finalize(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FullSolveMultiApp::FullSolveMultiApp(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVAdvection::FVAdvection(), FileMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MeshGenerator::getCSGBaseByName(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), NumFixedPointIterations::getValue(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), Eigenvalue::init(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), MFEMMesh::init(), FEProblemBase::init(), CompositionDT::init(), SubProblem::initialSetup(), PIDTransientControl::initialSetup(), RealFunctionControl::initialSetup(), TimePeriod::initialSetup(), EigenProblemSolve::initialSetup(), FEProblemSolve::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), BoundaryMeshBuilder::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), EigenProblem::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::meshChanged(), MeshGenerator::MeshGenerator(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), Checkpoint::output(), Exodus::output(), Nemesis::output(), PerfGraphOutput::output(), Tecplot::output(), MortarNodalGeometryOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), JSONOutput::outputReporters(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), JSONOutput::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), TransientBase::preExecute(), FEProblemBase::projectSolution(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), FileMesh::safeClone(), GeneratedMesh::safeClone(), ImageMesh::safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), MFEMFileMesh::safeClone(), MFEMMeshGeneratorMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SolutionInvalidityReporter::SolutionInvalidityReporter(), FixedPointSolve::solve(), ActuallyExplicitEuler::solve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), PetscOutput::solveSetup(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), SubProblem::timestepSetup(), PIDTransientControl::timestepSetup(), FEProblemBase::timestepSetup(), TransientBase::TransientBase(), MooseMesh::update(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), FEProblemBase::updateMortarMesh(), NEML2FEInterpolation::updatePhi(), Console::write(), XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve(), and FEProblemBase::~FEProblemBase().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _converge_on_group

std::vector<bool> ReferenceResidualConvergence::_converge_on_group

protected

Definition at line 131 of file ReferenceResidualConvergence.h.

Referenced by initialSetup(), and nonlinearConvergenceSetup().

◆ _converge_on_var

std::vector<bool> ReferenceResidualConvergence::_converge_on_var

protected

Flag for each solution variable or group being in 'converge_on'.

Definition at line 130 of file ReferenceResidualConvergence.h.

Referenced by initialSetup(), and updateReferenceResidual().

◆ _current_execute_flag

const ExecFlagType& SetupInterface::_current_execute_flag

protectedinherited

Reference to FEProblemBase.

Definition at line 86 of file SetupInterface.h.

Referenced by TimedSubdomainModifier::computeSubdomainID(), and PseudoTimestep::execute().

◆ _default_values

std::map<PostprocessorName, std::unique_ptr<PostprocessorValue> > PostprocessorInterface::_default_values

mutableprivateinherited

Holds the default postprocessor values that are requested (key is PostprocessorName)

Definition at line 162 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::getPostprocessorValueInternal().

◆ _div_threshold

const Real DefaultNonlinearConvergence::_div_threshold

protectedinherited

Divergence threshold value.

Definition at line 84 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ _dt

Real& TransientInterface::_dt

protectedinherited

Time step size.

Definition at line 79 of file TransientInterface.h.

Referenced by InterfaceQpValueUserObject::computeRealValue(), ForcingFunctionAux::computeValue(), PIDTransientControl::execute(), TimeIntegratedPostprocessor::execute(), ChangeOverTimePostprocessor::finalize(), VariableTimeIntegrationAux::getIntegralValue(), and PIDChainControl::updateValues().

◆ _dt_old

Real& TransientInterface::_dt_old

protectedinherited

Size of the old time step.

Definition at line 82 of file TransientInterface.h.

Referenced by VariableTimeIntegrationAux::getIntegralValue().

◆ _duplicate_shared_executioner_params

std::vector<std::string> DefaultConvergenceBase::_duplicate_shared_executioner_params

privateinherited

List of shared executioner parameters that have been set by the user in both places.

Definition at line 55 of file DefaultConvergenceBase.h.

Referenced by DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), and DefaultConvergenceBase::getSharedExecutionerParam().

◆ _empty_execute_enum

ExecFlagEnum SetupInterface::_empty_execute_enum

privateinherited

Empty ExecFlagEnum for the case when the "execute_on" parameter is not included.

This is private because others should not be messing with it.

Definition at line 79 of file SetupInterface.h.

Referenced by SetupInterface::SetupInterface().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _execute_enum

const ExecFlagEnum& SetupInterface::_execute_enum

protectedinherited

Execute settings for this object.

Definition at line 83 of file SetupInterface.h.

◆ _factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

Referenced by ElementIDOutputAction::act(), AdaptivityAction::act(), AddControlAction::act(), AddNodalNormalsAction::act(), AddPeriodicBCAction::act(), AutoCheckpointAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), SetupResidualDebugAction::act(), SetupTimeStepperAction::act(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), SampledOutput::cloneMesh(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), PhysicsBase::getFactory(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _fe_problem

FEProblemBase& DefaultNonlinearConvergence::_fe_problem

protectedinherited

Definition at line 78 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), DefaultNonlinearConvergence::checkPetscToleranceOverrides(), DefaultNonlinearConvergence::nonlinearSystem(), nonlinearSystem(), ReferenceResidualConvergence(), and DefaultNonlinearConvergence::setNonlinearSystemParameters().

◆ _group_index

std::vector<unsigned int> ReferenceResidualConvergence::_group_index

protected

Group number index for each variable.

Definition at line 118 of file ReferenceResidualConvergence.h.

Referenced by initialSetup(), and updateReferenceResidual().

◆ _group_names

std::vector<NonlinearVariableName> ReferenceResidualConvergence::_group_names

protected

List of grouped solution variable names whose reference residuals will be stored

Definition at line 88 of file ReferenceResidualConvergence.h.

Referenced by initialSetup(), and nonlinearConvergenceSetup().

◆ _group_ref_resid

std::vector<Real> ReferenceResidualConvergence::_group_ref_resid

protected

Local storage for discrete L2 residual norms of the grouped variables.

Definition at line 110 of file ReferenceResidualConvergence.h.

Referenced by checkConvergenceIndividVars(), initialSetup(), nonlinearConvergenceSetup(), and updateReferenceResidual().

◆ _group_resid

std::vector<Real> ReferenceResidualConvergence::_group_resid

protected

Definition at line 111 of file ReferenceResidualConvergence.h.

Referenced by checkConvergenceIndividVars(), initialSetup(), nonlinearConvergenceSetup(), and updateReferenceResidual().

◆ _group_variables

std::vector<std::vector<NonlinearVariableName> > ReferenceResidualInterface::_group_variables

protectedinherited

Name of variables that are grouped together to check convergence.

Definition at line 40 of file ReferenceResidualInterface.h.

Referenced by ReferenceResidualInterface::addGroupVariables(), initialSetup(), and ReferenceResidualInterface::ReferenceResidualInterface().

◆ _is_implicit

bool TransientInterface::_is_implicit

protectedinherited

If the object is using implicit or explicit form.

This does NOT mean time scheme, but which values are going to be used in the object - either from current time or old time. Note that even explicit schemes have implicit form (it is the time derivative "kernel")

Definition at line 67 of file TransientInterface.h.

Referenced by EigenKernel::computeJacobian(), EigenKernel::computeOffDiagJacobian(), BoundaryIntegralValueConstraint::computeResidualAndJacobian(), IntegratedBC::computeResidualAndJacobian(), NodalBC::computeResidualAndJacobian(), Kernel::computeResidualAndJacobian(), KernelScalarBase::computeResidualAndJacobian(), TransientInterface::determineState(), EigenKernel::EigenKernel(), EigenKernel::enabled(), and TransientInterface::isImplicit().

◆ _is_transient

bool TransientInterface::_is_transient

protectedinherited

Definition at line 85 of file TransientInterface.h.

Referenced by InterfaceTimeKernel::InterfaceTimeKernel().

◆ _is_var_grouped

std::vector<bool> ReferenceResidualConvergence::_is_var_grouped

protected

Vector of bools to signify if variable is in a group.

Definition at line 115 of file ReferenceResidualConvergence.h.

Referenced by initialSetup().

◆ _local_norm

bool ReferenceResidualConvergence::_local_norm

protected

Flag to optionally perform normalization of residual by reference residual before or after L2 norm is computed.

Definition at line 140 of file ReferenceResidualConvergence.h.

Referenced by checkConvergenceIndividVars(), nonlinearConvergenceSetup(), ReferenceResidualConvergence(), and updateReferenceResidual().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _nl_abs_div_tol

const Real DefaultNonlinearConvergence::_nl_abs_div_tol

protectedinherited

Nonlinear absolute divergence tolerance.

Definition at line 80 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ _nl_abs_tol

Real DefaultNonlinearConvergence::_nl_abs_tol

protectedinherited

Nonlinear absolute tolerance (modifiable by setAbsoluteTolerance)

Definition at line 98 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), DefaultNonlinearConvergence::checkPetscToleranceOverrides(), nonlinearConvergenceSetup(), DefaultNonlinearConvergence::setAbsoluteTolerance(), and DefaultNonlinearConvergence::setNonlinearSystemParameters().

◆ _nl_checked_petsc_tolerance_overrides

bool DefaultNonlinearConvergence::_nl_checked_petsc_tolerance_overrides = false

privateinherited

Whether checkPetscToleranceOverrides() has already run for this simulation.

Definition at line 104 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkPetscToleranceOverrides().

◆ _nl_current_pingpong

unsigned int DefaultNonlinearConvergence::_nl_current_pingpong

protectedinherited

Current number of nonlinear ping-pong iterations for the current solve.

Definition at line 90 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ _nl_forced_its

unsigned int DefaultNonlinearConvergence::_nl_forced_its

protectedinherited

Number of iterations to force.

Definition at line 86 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ _nl_max_funcs

const unsigned int DefaultNonlinearConvergence::_nl_max_funcs

protectedinherited

Maximum number of residual (function) evaluations.

Definition at line 94 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), DefaultNonlinearConvergence::checkPetscToleranceOverrides(), and DefaultNonlinearConvergence::setNonlinearSystemParameters().

◆ _nl_max_its

unsigned int DefaultNonlinearConvergence::_nl_max_its

protectedinherited

Nonlinear maximum nonlinear iterations (modifiable by setMaximumIterations)

Definition at line 96 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkPetscToleranceOverrides(), DefaultNonlinearConvergence::setMaximumIterations(), and DefaultNonlinearConvergence::setNonlinearSystemParameters().

◆ _nl_max_pingpong

const unsigned int DefaultNonlinearConvergence::_nl_max_pingpong

protectedinherited

Maximum number of nonlinear ping-pong iterations for a solve.

Definition at line 88 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ _nl_rel_div_tol

const Real DefaultNonlinearConvergence::_nl_rel_div_tol

protectedinherited

Nonlinear relative divergence tolerance.

Definition at line 82 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence().

◆ _nl_rel_step_tol

const Real DefaultNonlinearConvergence::_nl_rel_step_tol

protectedinherited

Nonlinear relative step tolerance.

Definition at line 92 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), DefaultNonlinearConvergence::checkPetscToleranceOverrides(), and DefaultNonlinearConvergence::setNonlinearSystemParameters().

◆ _nl_rel_tol

Real DefaultNonlinearConvergence::_nl_rel_tol

protectedinherited

Nonlinear relative tolerance (modifiable by setRelativeTolerance)

Definition at line 100 of file DefaultNonlinearConvergence.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), DefaultNonlinearConvergence::checkPetscToleranceOverrides(), nonlinearConvergenceSetup(), DefaultNonlinearConvergence::setNonlinearSystemParameters(), and DefaultNonlinearConvergence::setRelativeTolerance().

◆ _nl_sys_num

const unsigned int ReferenceResidualConvergence::_nl_sys_num

protected

Nonlinear system to which this convergence object applies.

Definition at line 106 of file ReferenceResidualConvergence.h.

Referenced by nonlinearSystem(), and ReferenceResidualConvergence().

◆ _norm_type

libMesh::FEMNormType ReferenceResidualConvergence::_norm_type

protected

Container for normalization type.

Definition at line 143 of file ReferenceResidualConvergence.h.

Referenced by ReferenceResidualConvergence(), and updateReferenceResidual().

◆ _norm_type_enum

const MooseEnum ReferenceResidualConvergence::_norm_type_enum

protected

Enum holding the normalization type.

Definition at line 77 of file ReferenceResidualConvergence.h.

Referenced by nonlinearConvergenceSetup(), and ReferenceResidualConvergence().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseApp::MooseApp(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _perfid_check_convergence

PerfID Convergence::_perfid_check_convergence

protectedinherited

Performance ID for checkConvergence.

Definition at line 82 of file Convergence.h.

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), DefaultNonlinearConvergence::checkConvergence(), and DefaultSteadyStateConvergence::checkConvergence().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _ppi_feproblem

const FEProblemBase& PostprocessorInterface::_ppi_feproblem

privateinherited

Reference the the FEProblemBase class.

Definition at line 159 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::hasPostprocessorByName(), PostprocessorInterface::isDefaultPostprocessorValueByName(), and PostprocessorInterface::postprocessorsAdded().

◆ _ppi_moose_object

const MooseObject& PostprocessorInterface::_ppi_moose_object

privateinherited

The MooseObject that uses this interface.

Definition at line 153 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::checkParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), and PostprocessorInterface::hasPostprocessorByName().

◆ _ppi_params

const InputParameters& PostprocessorInterface::_ppi_params

privateinherited

PostprocessorInterface Parameters.

Definition at line 156 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::checkParam(), PostprocessorInterface::coupledPostprocessors(), and PostprocessorInterface::getPostprocessorNameInternal().

◆ _prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _ref_resid_var_names

std::vector<AuxVariableName> ReferenceResidualConvergence::_ref_resid_var_names

protected

Definition at line 83 of file ReferenceResidualConvergence.h.

◆ _ref_resid_vars

std::vector<unsigned int> ReferenceResidualConvergence::_ref_resid_vars

protected

Definition at line 94 of file ReferenceResidualConvergence.h.

◆ _reference_vector

const NumericVector<Number>* ReferenceResidualConvergence::_reference_vector

protected

The vector storing the reference residual values.

Definition at line 127 of file ReferenceResidualConvergence.h.

Referenced by checkResidualConvergence(), initialSetup(), nonlinearConvergenceSetup(), ReferenceResidualConvergence(), and updateReferenceResidual().

◆ _reference_vector_tag_id

TagID ReferenceResidualConvergence::_reference_vector_tag_id

protected

The reference vector tag id.

Definition at line 146 of file ReferenceResidualConvergence.h.

Referenced by ReferenceResidualConvergence(), and referenceVectorTagID().

◆ _residual_vector

const NumericVector<Number>* ReferenceResidualConvergence::_residual_vector

protected

The optional vector storing the reference residual values.

Definition at line 124 of file ReferenceResidualConvergence.h.

Referenced by ReferenceResidualConvergence(), and updateReferenceResidual().

◆ _scaling_factors

std::vector<Real> ReferenceResidualConvergence::_scaling_factors

protected

Local storage for the scaling factors applied to each of the variables to apply to _ref_resid_vars.

Definition at line 121 of file ReferenceResidualConvergence.h.

Referenced by initialSetup(), and updateReferenceResidual().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _soln_var_names

std::vector<NonlinearVariableName> ReferenceResidualConvergence::_soln_var_names

protected

List of solution variable names whose reference residuals will be stored, and the residual variable names that will store them.

Definition at line 82 of file ReferenceResidualConvergence.h.

Referenced by initialSetup().

◆ _soln_vars

std::vector<unsigned int> ReferenceResidualConvergence::_soln_vars

protected

Variable numbers associated with the names in _soln_var_names and _ref_resid_var_names.

Definition at line 93 of file ReferenceResidualConvergence.h.

Referenced by initialSetup(), and updateReferenceResidual().

◆ _t

Real& TransientInterface::_t

protectedinherited

Time.

Definition at line 70 of file TransientInterface.h.

◆ _t_old

const Real& TransientInterface::_t_old

protectedinherited

Old time.

Definition at line 73 of file TransientInterface.h.

Referenced by FVFunctionDirichletBC::boundaryValue(), and TimedSubdomainModifier::computeSubdomainID().

◆ _t_step

int& TransientInterface::_t_step

protectedinherited

The number of the time step.

Definition at line 76 of file TransientInterface.h.

Referenced by NEML2ModelExecutor::advanceState(), PIDTransientControl::execute(), AccumulateReporter::execute(), IterationInfo::execute(), LeastSquaresFitHistory::execute(), NEML2ModelExecutor::fillInputs(), ChangeOverFixedPointPostprocessor::finalize(), ChangeOverTimePostprocessor::finalize(), and ElementSubdomainModifierBase::timestepSetup().

◆ _ti_feproblem

FEProblemBase& TransientInterface::_ti_feproblem

protectedinherited

Definition at line 59 of file TransientInterface.h.

Referenced by Function::evaluate(), Function::evaluateDotHelper(), Function::evaluateGradientHelper(), Function::evaluateHelper(), PiecewiseConstantFromCSV::initialSetup(), and PiecewiseConstantFromCSV::PiecewiseConstantFromCSV().

◆ _ti_name

const std::string TransientInterface::_ti_name

privateinherited

Definition at line 88 of file TransientInterface.h.

◆ _ti_params

const InputParameters& TransientInterface::_ti_params

protectedinherited

Definition at line 57 of file TransientInterface.h.

◆ _tid

THREAD_ID Convergence::_tid

protectedinherited

Thread ID.

Definition at line 85 of file Convergence.h.

Referenced by ParsedConvergence::initializeConvergenceSymbol(), and ParsedConvergence::initializeFunctionSymbol().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _unscale_the_residual

const bool ReferenceResidualConvergence::_unscale_the_residual

protected

Bool to unscale the residual before convergence checks and screen output.

Definition at line 137 of file ReferenceResidualConvergence.h.

Referenced by updateReferenceResidual().

◆ _use_group_variables

bool ReferenceResidualInterface::_use_group_variables

protectedinherited

True if any variables are grouped.

Definition at line 43 of file ReferenceResidualInterface.h.

Referenced by ReferenceResidualInterface::addGroupVariables(), initialSetup(), and ReferenceResidualInterface::ReferenceResidualInterface().

◆ _verbose

const bool Convergence::_verbose

privateinherited

Verbose mode enabled.

Definition at line 89 of file Convergence.h.

Referenced by Convergence::verbose().

◆ _zero_ref_type

enum ReferenceResidualConvergence::ZeroReferenceType ReferenceResidualConvergence::_zero_ref_type

protected

Referenced by checkConvergenceIndividVars().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

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

include/convergence/ReferenceResidualConvergence.h
src/convergence/ReferenceResidualConvergence.C

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

◆ IterationType

Member Enumeration Documentation

◆ MooseConvergenceStatus

◆ ZeroReferenceType

Constructor & Destructor Documentation

◆ ReferenceResidualConvergence()

Member Function Documentation

◆ addGroupVariables()

◆ addPostprocessorDependencyHelper()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkConvergence()

◆ checkConvergenceIndividVars()

◆ checkDuplicateSetSharedExecutionerParams()

◆ checkIterationType()

◆ checkParam()

◆ checkPetscToleranceOverrides()

◆ checkResidualConvergence()

◆ connectControllableParams()

◆ coupledPostprocessors()

◆ customSetup()

◆ determineState()

◆ enabled()

◆ errorPrefix()

◆ flagInvalidSolutionInternal()

◆ getBase()

◆ getCheckedPointerParam()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getDefaultPostprocessorValueByName()

◆ getExecuteOnEnum()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getPostprocessorName()

◆ getPostprocessorNameInternal()

◆ getPostprocessorValue()

◆ getPostprocessorValueByName()

◆ getPostprocessorValueByNameInternal()

◆ getPostprocessorValueInternal()

◆ getPostprocessorValueOld()

◆ getPostprocessorValueOldByName()

◆ getPostprocessorValueOlder()

◆ getPostprocessorValueOlderByName()

◆ getRenamedParam()

◆ getSharedExecutionerParam()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ hasBase()

◆ hasPostprocessor()

◆ hasPostprocessorByName()

◆ initialSetup()

◆ isDefaultPostprocessorValue()

◆ isDefaultPostprocessorValueByName()

◆ isImplicit()

◆ isKokkosObject()

◆ isParamSetByUser()

◆ isParamValid()

◆ jacobianSetup()

◆ messagePrefix() [1/2]

◆ messagePrefix() [2/2]

◆ mooseDeprecated() [1/2]