Adjust the timestep based on the number of iterations. More...

#include <IterationAdaptiveDT.h>

Inheritance diagram for IterationAdaptiveDT:

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

Public Member Functions
	IterationAdaptiveDT (const InputParameters &parameters)

virtual void	init () override
	Initialize the time stepper. More...

virtual void	preExecute () override

virtual void	rejectStep () override
	This gets called when time step is rejected. More...

virtual void	acceptStep () override
	This gets called when time step is accepted. More...

virtual bool	constrainStep (Real &dt) override
	Called after computeStep() is called. More...

virtual void	preSolve ()

virtual void	postSolve ()

virtual void	postExecute ()

virtual void	preStep ()

virtual void	postStep ()

void	computeStep ()
	Called before a new step is started. More...

virtual void	step ()
	Take a time step. More...

unsigned int	numFailures () const
	Gets the number of failures and returns them. More...

Real	getCurrentDT ()
	Get the current_dt. More...

virtual void	forceTimeStep (Real dt)

virtual void	forceNumSteps (const unsigned int num_steps)
	Set the number of time steps. More...

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

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

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

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

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

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

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

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

void	callMooseError (std::string msg, const bool with_prefix) const
	Calls moose error with the message `msg`. More...

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
	The unique parameter name of a valid parameter of this object for accessing parameter controls. More...

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

MooseObjectName	uniqueName () const
	The unique name for accessing input parameters of this object in the InputParameterWarehouse. More...

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

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. More...

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

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

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. More...

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

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

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. More...

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. More...

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. More...

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. More...

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type. More...

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

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
	Emits a documented error with object name and type. More...

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

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

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

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

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. More...

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

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

const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()
	Get the list of coupled scalar variables. More...

const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const

const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const

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

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

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

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

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


void	addSyncTime (Real sync_time)
	Add a sync time. More...

void	addSyncTime (const std::set< Real > &times)


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 More...

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. More...

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

Static Public Member Functions
static InputParameters	validParams ()

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

Protected Member Functions
virtual Real	computeInitialDT () override
	Computes time step size for the initial time step. More...

virtual Real	computeDT () override
	Computes time step size after the initial time step. More...

virtual Real	computeFailedDT () override
	Computes time step size after a failed time step. More...

virtual bool	converged () const override
	If the time step converged. More...

void	computeAdaptiveDT (Real &dt, bool allowToGrow=true, bool allowToShrink=true)

Real	computeInterpolationDT ()

void	limitDTByFunction (Real &limitedDT)

void	limitDTToPostprocessorValue (Real &limitedDT) const

template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...

template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it. More...

template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to `declareRestartableData` but returns a const reference to the object. More...

template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...

template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable". More...

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable". More...

std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...

bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const
	Returns true if a variables has been coupled_as name. More...

unsigned int	coupledScalarComponents (const std::string &var_name) const
	Return the number of components to the coupled scalar variable. More...

unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const
	Returns the index for a scalar coupled variable by name. More...

libMesh::Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const
	Returns the order for a scalar coupled variable by name. More...

const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a scalar coupled variable. More...

const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns AD value of a scalar coupled variable. More...

template<bool is_ad>
const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled scalar variable for use in templated automatic differentiation classes. More...

template<>
const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

template<>
const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const

const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
	Returns value of a scalar coupled variable. More...

const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
	Returns value of a scalar coupled variable. More...

const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old (previous time step) value of a scalar coupled variable. More...

const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const
	Returns the older (two time steps previous) value of a scalar coupled variable. More...

const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const
	Returns the time derivative of a scalar coupled variable. More...

const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const
	Returns the time derivative of a scalar coupled variable, including its dependence on the nonlinear degrees of freedom through automatic differentiation. More...

const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const
	Returns the second time derivative of a scalar coupled variable. More...

const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old time derivative of a scalar coupled variable. More...

const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old second time derivative of a scalar coupled variable. More...

const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a scalar coupled variable with respect to the coefficients. More...

const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a scalar coupled variable with respect to the coefficients. More...

const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const
	Extract pointer to a scalar coupled variable. More...

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

Protected Attributes
Real &	_dt_old

const Real	_input_dt
	The dt from the input file. More...

bool &	_tfunc_last_step

bool &	_sync_last_step

int	_optimal_iterations
	Adapt the timestep to maintain this non-linear iteration count... More...

int	_iteration_window
	...plus/minus this value. More...

const int	_linear_iteration_ratio
	use _optimal_iterations and _iteration_window multiplied with this factor for linear iterations More...

bool	_adaptive_timestepping
	adaptive timestepping is active if the optimal_iterations input parameter is specified More...

std::vector< const PostprocessorValue * >	_pps_value
	if specified, the postprocessor values used to determine an upper limit for the time step length More...

std::vector< const Function * >	_timestep_limiting_functions

std::vector< const PiecewiseBase * >	_piecewise_timestep_limiting_functions

std::vector< const PiecewiseLinear * >	_piecewise_linear_timestep_limiting_functions

std::vector< Real >	_times
	time point defined in the piecewise function More...

Real	_max_function_change

const bool	_force_step_every_function_point
	insert sync points at the time nodes of the _piecewise_timestep_limiting_function More...

const Real	_post_function_sync_dt
	Set timestep size if previous timestep is synced with function. More...

std::set< Real >	_tfunc_times

LinearInterpolation	_time_ipol
	PiecewiseBase linear definition of time stepping. More...

const bool	_use_time_ipol
	true if we want to use piecewise-defined time stepping More...

const Real &	_growth_factor
	grow the timestep by this factor More...

const Real &	_cutback_factor
	cut the timestep by by this factor More...

unsigned int &	_outer_its
	Number of outer solver iterations in previous solve. More...

unsigned int &	_nl_its

unsigned int &	_l_its
	Number of linear iterations in previous solve. More...

bool &	_cutback_occurred

bool	_at_function_point

bool	_reject_large_step
	Indicates whether we need to reject a time step much larger than its ideal size. More...

double	_large_step_rejection_threshold
	Threshold used to detect whether we need to reject a step. More...

std::optional< Real >	_dt_from_reject
	Timestep used to reject a timestep, used to constrain the next attempt. More...

FEProblemBase &	_fe_problem

TransientBase &	_executioner
	Reference to transient executioner. More...

Real &	_time
	Values from executioner. More...

Real &	_time_old

int &	_t_step

Real &	_dt

Real &	_dt_min

Real &	_dt_max

Real &	_end_time

std::set< Real > &	_sync_times

Real &	_timestep_tolerance

const bool &	_verbose
	whether a detailed diagnostic output should be printed More...

bool	_converged
	Whether or not the previous solve converged. More...

const Real	_cutback_factor_at_failure
	Cutback factor if a time step fails to converge. More...

bool	_reset_dt
	If true then the next dt will be computed by computeInitialDT() More...

bool	_has_reset_dt
	True if dt has been reset. More...

unsigned int	_failure_count
	Cumulative amount of steps that have failed. More...

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

MooseApp &	_app
	The MOOSE application this is associated with. More...

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

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

const InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...

Factory &	_factory
	The Factory associated with the MooseApp. More...

ActionFactory &	_action_factory
	Builds Actions. More...

const Parallel::Communicator &	_communicator

MooseApp &	_restartable_app
	Reference to the application. More...

const std::string	_restartable_system_name
	The system name this object is in. More...

const THREAD_ID	_restartable_tid
	The thread ID for this object. More...

const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...

FEProblemBase &	_sc_fe_problem

const THREAD_ID	_sc_tid
	Thread ID of the thread using this object. More...

const Real &	_real_zero
	Scalar zero. More...

const VariableValue &	_scalar_zero
	Zero value of a scalar variable. More...

const Point &	_point_zero
	Zero point. More...

Detailed Description

Adjust the timestep based on the number of iterations.

The user can specitfy an optimal_iterations number of non-linear iterations and an iteration_window. The time stepper attempts to increase the time step if the non-linear iteration count is below optimal_iterations - iteration_window and it attempts to reduce the time step if the non-linear iteration count is above optimal_iterations + iteration_window. Similar rules apply to the number of linear iterations with the multiplier linear_iteration_ratio applied to optimal_iterations and iteration_window. This time stepper allows the user to specify a function that limits the maximal time step change. This time stepper allows the user to specify a limiting time step length through a postprocessor.

Definition at line 32 of file IterationAdaptiveDT.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.

Constructor & Destructor Documentation

◆ IterationAdaptiveDT()

IterationAdaptiveDT::IterationAdaptiveDT ( const InputParameters & parameters )

Definition at line 95 of file IterationAdaptiveDT.C.

   : TimeStepper(parameters),
     PostprocessorInterface(this),
     _dt_old(declareRestartableData<Real>("dt_old", 0.0)),
     _input_dt(getParam<Real>("dt")),
     _tfunc_last_step(declareRestartableData<bool>("tfunc_last_step", false)),
     _sync_last_step(declareRestartableData<bool>("sync_last_step", false)),
     _linear_iteration_ratio(isParamValid("linear_iteration_ratio")
                                 ? getParam<unsigned>("linear_iteration_ratio")
                                 : 25), // Default to 25
     _adaptive_timestepping(false),
     _pps_value(
         parameters.get<std::vector<PostprocessorName>>("timestep_limiting_postprocessor").size()),
     _timestep_limiting_functions(),
     _piecewise_timestep_limiting_functions(),
     _piecewise_linear_timestep_limiting_functions(),
     _times(0),
     _max_function_change(-1),
     _force_step_every_function_point(getParam<bool>("force_step_every_function_point")),
     _post_function_sync_dt(isParamValid("force_step_every_function_point") &&
                                    isParamValid("post_function_sync_dt")
                                ? getParam<Real>("post_function_sync_dt")
                                : 0.0),
     _tfunc_times(getParam<std::vector<Real>>("time_t").begin(),
                  getParam<std::vector<Real>>("time_t").end()),
     _time_ipol(getParam<std::vector<Real>>("time_t"), getParam<std::vector<Real>>("time_dt")),
     _use_time_ipol(_time_ipol.getSampleSize() > 0),
     _growth_factor(getParam<Real>("growth_factor")),
     _cutback_factor(getParam<Real>("cutback_factor")),
     _outer_its(declareRestartableData<unsigned int>("outer_its", 0)),
     _nl_its(_outer_its),
     _l_its(declareRestartableData<unsigned int>("l_its", 0)),
     _cutback_occurred(declareRestartableData<bool>("cutback_occurred", false)),
     _at_function_point(false),
     _reject_large_step(getParam<bool>("reject_large_step")),
     _large_step_rejection_threshold(getParam<Real>("reject_large_step_threshold"))
 {
   auto timestep_limiting_postprocessor_names =
       parameters.get<std::vector<PostprocessorName>>("timestep_limiting_postprocessor");
   for (size_t i = 0; i < _pps_value.size(); ++i)
     _pps_value[i] = &getPostprocessorValueByName(timestep_limiting_postprocessor_names[i]);
 
   if (isParamValid("optimal_iterations"))
   {
     _adaptive_timestepping = true;
     _optimal_iterations = getParam<int>("optimal_iterations");
 
     if (isParamValid("iteration_window"))
       _iteration_window = getParam<int>("iteration_window");
     else
       _iteration_window = ceil(_optimal_iterations / 5.0);
   }
   else
   {
     if (isParamValid("iteration_window"))
       mooseError("'optimal_iterations' must be used for 'iteration_window' to be used");
     if (isParamValid("linear_iteration_ratio"))
       mooseError("'optimal_iterations' must be used for 'linear_iteration_ratio' to be used");
   }
 
   if (isParamValid("timestep_limiting_function"))
     _max_function_change =
         isParamValid("max_function_change") ? getParam<Real>("max_function_change") : -1;
   else
   {
     if (isParamValid("max_function_change"))
       mooseError("'timestep_limiting_function' must be used for 'max_function_change' to be used");
     if (_force_step_every_function_point)
       mooseError("'timestep_limiting_function' must be used for 'force_step_every_function_point' "
                  "to be used");
   }
 
   if (!isParamValid("force_step_every_function_point") && isParamValid("post_function_sync_dt"))
     paramError("post_function_sync_dt",
                "Not applicable if 'force_step_every_function_point = false'");
 }

Member Function Documentation

◆ acceptStep()

void IterationAdaptiveDT::acceptStep ( )

overridevirtual

This gets called when time step is accepted.

Reimplemented from TimeStepper.

Definition at line 571 of file IterationAdaptiveDT.C.

 {
   TimeStepper::acceptStep();
 
   _tfunc_last_step = false;
   while (!_tfunc_times.empty() && _time + _timestep_tolerance >= *_tfunc_times.begin())
   {
     if (std::abs(_time - *_tfunc_times.begin()) <= _timestep_tolerance)
       _tfunc_last_step = true;
 
     _tfunc_times.erase(_tfunc_times.begin());
   }
 
   // Reset counts
   _outer_its = 0;
   _l_its = 0;
 
   // Use the total number of iterations for multi-system
   for (const auto i : make_range(_fe_problem.numNonlinearSystems()))
     _outer_its += _fe_problem.getNonlinearSystemBase(/*nl_sys=*/i).nNonlinearIterations();
   // Add linear iterations for both nonlinear and linear systems for multi-system
   for (const auto i : make_range(_fe_problem.numNonlinearSystems()))
     _l_its += _fe_problem.getNonlinearSystemBase(/*nl_sys=*/i).nLinearIterations();
   for (const auto i : make_range(_fe_problem.numLinearSystems()))
   {
     _l_its += _fe_problem.getLinearSystem(/*nl_sys=*/i).nLinearIterations();
     _outer_its += _fe_problem.getLinearSystem(/*nl_sys=*/i).nLinearIterations();
   }
 
   if ((_at_function_point || _executioner.atSyncPoint()) &&
       _dt + _timestep_tolerance < _executioner.unconstrainedDT())
   {
     _dt_old = _fe_problem.dtOld();
     _sync_last_step = true;
 
     if (_verbose)
       _console << "Sync point hit in current step, using previous dt for old dt: " << std::setw(9)
                << _dt_old << std::endl;
   }
   else
     _dt_old = _dt;
 }

◆ adCoupledScalarDot()

const ADVariableValue & ScalarCoupleable::adCoupledScalarDot	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the time derivative of a scalar coupled variable, including its dependence on the nonlinear degrees of freedom through automatic differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to the time derivative at quadrature points for the coupled variable, including automatic differentiation information

Definition at line 252 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   validateExecutionerType(var_name, "adCoupledScalarDot");
   return getScalarVar(var_name, comp)->adUDot();
 }

◆ adCoupledScalarValue()

const ADVariableValue & ScalarCoupleable::adCoupledScalarValue	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns AD value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a ADVariableValue for the coupled variable

Definition at line 135 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   if (!isCoupledScalar(var_name, comp))
     return *getADDefaultValue(var_name);
 
   auto var = getScalarVar(var_name, comp);
 
   if (_sc_is_implicit)
     return var->adSln();
   else
     mooseError("adCoupledValue for non-implicit calculations is not currently supported. Use "
                "coupledValue instead for non-implicit");
 }

◆ 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 AuxKernelTempl< ComputeValueType >, AuxKernelTempl< RT >, AuxKernelTempl< RealVectorValue >, AuxKernelTempl< Real >, UserObject, and InitialConditionBase.

Definition at line 141 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal().

141 {}

◆ addSyncTime() [1/2]

void TimeStepper::addSyncTime ( Real sync_time )

inherited

Add a sync time.

Todo:: {Remove after old output system is removed; sync time are handled by OutputWarehouse}

◆ addSyncTime() [2/2]

void TimeStepper::addSyncTime ( const std::set< Real > & times )

inherited

◆ callMooseError()

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

inherited

Calls moose error with the message msg.

Will prefix the message with the subapp name if one exists.

If with_prefix, then add the prefix from errorPrefix() to the error.

Definition at line 33 of file MooseBase.C.

Referenced by InputParameters::callMooseErrorHelper(), MooseBaseErrorInterface::mooseDocumentedError(), MooseBaseErrorInterface::mooseError(), MooseBaseErrorInterface::mooseErrorNonPrefixed(), and MooseBaseParameterInterface::paramError().

 {
   _app.getOutputWarehouse().mooseConsole();
   const std::string prefix = _app.isUltimateMaster() ? "" : _app.name();
   if (with_prefix)
     msg = errorPrefix("error") + msg;
   moose::internal::mooseErrorRaw(msg, prefix);
 }

◆ computeAdaptiveDT()

void IterationAdaptiveDT::computeAdaptiveDT	(	Real &	dt,
		bool	allowToGrow = `true`,
		bool	allowToShrink = `true`
	)

protected

Definition at line 509 of file IterationAdaptiveDT.C.

Referenced by computeDT().

 {
   const unsigned int growth_outer_its(
       _optimal_iterations > _iteration_window ? _optimal_iterations - _iteration_window : 0);
   const unsigned int shrink_outer_its(_optimal_iterations + _iteration_window);
   const unsigned int growth_l_its(_optimal_iterations > _iteration_window
                                       ? _linear_iteration_ratio *
                                             (_optimal_iterations - _iteration_window)
                                       : 0);
   const unsigned int shrink_l_its(_linear_iteration_ratio *
                                   (_optimal_iterations + _iteration_window));
   const std::string ite_type = (_fe_problem.numLinearSystems() == 0) ? "nl" : "solver";
 
   if (allowToGrow && (_outer_its < growth_outer_its && _l_its < growth_l_its))
   {
     // Grow the timestep
     dt *= _growth_factor;
 
     if (_verbose)
       _console << "Growing dt: " + ite_type + " its = " << _outer_its << " < " << growth_outer_its
                << " && lin its = " << _l_its << " < " << growth_l_its << " old dt: " << std::setw(9)
                << _dt_old << " new dt: " << std::setw(9) << dt << '\n';
   }
   else if (allowToShrink && (_outer_its > shrink_outer_its || _l_its > shrink_l_its))
   {
     // Shrink the timestep
     dt *= _cutback_factor;
 
     if (_verbose)
       _console << "Shrinking dt: " + ite_type + " its = " << _outer_its << " > " << shrink_outer_its
                << " || lin its = " << _l_its << " > " << shrink_l_its << " old dt: " << std::setw(9)
                << _dt_old << " new dt: " << std::setw(9) << dt << '\n';
   }
 
   _console << std::flush;
 }

◆ computeDT()

Real IterationAdaptiveDT::computeDT ( )

overrideprotectedvirtual

Computes time step size after the initial time step.

Implements TimeStepper.

Definition at line 243 of file IterationAdaptiveDT.C.

 {
   Real dt = _dt_old;
 
   if (_cutback_occurred)
   {
     _cutback_occurred = false;
     if (_adaptive_timestepping)
     {
       // Don't allow it to grow this step, but shrink if needed
       bool allowToGrow = false;
       computeAdaptiveDT(dt, allowToGrow);
     }
   }
   else if (_tfunc_last_step)
   {
     _sync_last_step = false;
     dt = _time_ipol.sample(_time_old);
 
     if (_verbose)
       _console << "Setting dt to value specified by dt function: " << std::setw(9) << dt
                << std::endl;
   }
   else if (_sync_last_step)
   {
     _sync_last_step = false;
     if (_post_function_sync_dt)
     {
       dt = _post_function_sync_dt;
 
       if (_verbose)
         _console << "Setting dt to 'post_function_sync_dt': " << std::setw(9) << dt << std::endl;
     }
     else
     {
       dt = _executioner.unconstrainedDT();
 
       if (_verbose)
         _console << "Setting dt to unconstrained value used before sync: " << std::setw(9) << dt
                  << std::endl;
     }
   }
   else if (_adaptive_timestepping)
     computeAdaptiveDT(dt);
   else if (_use_time_ipol)
     dt = computeInterpolationDT();
   else
   {
     dt *= _growth_factor;
     if (dt > _dt_old * _growth_factor)
       dt = _dt_old * _growth_factor;
     if (_verbose)
       _console << "Growing dt based on growth factor (" << _growth_factor
                << ") and previous dt before sync (" << _dt_old << ") : " << std::setw(9) << dt
                << std::endl;
   }
 
   return dt;
 }

◆ computeFailedDT()

Real IterationAdaptiveDT::computeFailedDT ( )

overrideprotectedvirtual

Computes time step size after a failed time step.

Reimplemented from TimeStepper.

Definition at line 335 of file IterationAdaptiveDT.C.

 {
   _cutback_occurred = true;
 
   // Can't cut back any more
   if (_dt <= _dt_min)
     mooseError("Solve failed and timestep already at dtmin, cannot continue!");
 
   if (_verbose)
   {
     _console << "\nSolve failed with dt: " << std::setw(9) << _dt
              << "\nRetrying with reduced dt: " << std::setw(9) << _dt * _cutback_factor_at_failure
              << std::endl;
   }
   else
     _console << "\nSolve failed, cutting timestep." << std::endl;
 
   return _dt * _cutback_factor_at_failure;
 }

◆ computeInitialDT()

Real IterationAdaptiveDT::computeInitialDT ( )

overrideprotectedvirtual

Computes time step size for the initial time step.

Implements TimeStepper.

Definition at line 223 of file IterationAdaptiveDT.C.

 {
   Real dt;
   if (_tfunc_last_step)
   {
     dt = _time_ipol.sample(_time_old);
     if (_verbose)
       _console << "Setting initial dt to value specified by dt function: " << std::setw(9) << dt
                << std::endl;
   }
   else
   {
     dt = _input_dt;
     if (_verbose)
       _console << "Setting initial dt to input value: " << std::setw(9) << dt << std::endl;
   }
   return dt;
 }

◆ computeInterpolationDT()

Real IterationAdaptiveDT::computeInterpolationDT ( )

protected

Definition at line 547 of file IterationAdaptiveDT.C.

Referenced by computeDT().

 {
   Real dt = _time_ipol.sample(_time_old);
 
   if (dt > _dt_old * _growth_factor)
   {
     dt = _dt_old * _growth_factor;
 
     if (_verbose)
       _console << "Growing dt to recover from cutback. "
                << " old dt: " << std::setw(9) << _dt_old << " new dt: " << std::setw(9) << dt
                << std::endl;
   }
 
   return dt;
 }

◆ computeStep()

void TimeStepper::computeStep ( )

inherited

Called before a new step is started.

This is when the actual computation of the current DT will be done. Because of that this MUST be called only once per step!

After calling this function use getCurrentDT() to get the DT that was computed.

Definition at line 78 of file TimeStepper.C.

Referenced by TransientBase::computeDT().

 {
   if (_t_step < 2 || (_reset_dt && !_has_reset_dt))
   {
     _has_reset_dt = true;
 
     if (converged())
       _current_dt = computeInitialDT();
     else
       _current_dt = computeFailedDT();
   }
   else
   {
     if (converged())
       _current_dt = computeDT();
     else
       _current_dt = computeFailedDT();
   }
   if (_current_dt < -TOLERANCE)
     mooseError("Negative time step detected :" + std::to_string(_current_dt) +
                " Investigate the TimeStepper to resolve this error");
 }

◆ connectControllableParams()

void MooseBaseParameterInterface::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 33 of file MooseBaseParameterInterface.C.

 {
   MooseObjectParameterName primary_name(uniqueName(), parameter);
   const auto base_type = _factory.getValidParams(object_type).get<std::string>("_moose_base");
   MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
   _moose_base.getMooseApp().getInputParameterWarehouse().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, _moose_base.name(), parameter);
       _moose_base.getMooseApp().getInputParameterWarehouse().addControllableParameterConnection(
           tagged_name, secondary_name, /*error_on_empty=*/false);
     }
   }
 }

◆ constrainStep()

bool IterationAdaptiveDT::constrainStep ( Real & dt )

overridevirtual

Called after computeStep() is called.

Returns: true if any type of sync point was hit, false otherwise

Reimplemented from TimeStepper.

Definition at line 304 of file IterationAdaptiveDT.C.

 {
   bool at_sync_point = TimeStepper::constrainStep(dt);
 
   // Use value from computed dt while rejecting the timestep
   if (_dt_from_reject)
   {
     dt = *_dt_from_reject;
     _dt_from_reject.reset();
   }
   // Otherwise, limit the timestep to the current postprocessor value
   else
     limitDTToPostprocessorValue(dt);
 
   // Limit the timestep to limit change in the function
   limitDTByFunction(dt);
 
   // Adjust to the next tfunc time if needed
   if (!_tfunc_times.empty() && _time + dt + _timestep_tolerance >= *_tfunc_times.begin())
   {
     dt = *_tfunc_times.begin() - _time;
 
     if (_verbose)
       _console << "Limiting dt to sync with dt function time: " << std::setw(9)
                << *_tfunc_times.begin() << " dt: " << std::setw(9) << dt << std::endl;
   }
 
   return at_sync_point;
 }

◆ converged()

bool IterationAdaptiveDT::converged ( ) const

overrideprotectedvirtual

If the time step converged.

Returns: true if converged, otherwise false

Reimplemented from TimeStepper.

Definition at line 356 of file IterationAdaptiveDT.C.

 {
   if (!_reject_large_step)
     return TimeStepper::converged();
 
   // the solver has not converged
   if (!TimeStepper::converged())
     return false;
 
   // we are already at dt_min or at the start of the simulation
   // in which case we can move on to the next step
   if (_dt == _dt_min || _t_step < 2)
     return true;
 
   // This means we haven't tried constraining the latest step yet
   if (_dt_from_reject)
     return false;
 
   // we get what the next time step should be
   Real dt_test = _dt;
   limitDTToPostprocessorValue(dt_test);
 
   // we cannot constrain the time step any further
   if (dt_test == 0)
     return true;
 
   // if the time step is much smaller than the current time step
   // we need to repeat the current iteration with a smaller time step
   if (dt_test < _dt * _large_step_rejection_threshold)
   {
     _dt_from_reject = dt_test;
     return false;
   }
 
   // otherwise we move one
   return true;
 }

◆ coupledGenericScalarValue() [1/3]

template<bool is_ad>

const GenericVariableValue<is_ad>& ScalarCoupleable::coupledGenericScalarValue	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns value of a coupled scalar variable for use in templated automatic differentiation classes.

Parameters

var_name	Name of coupled scalar variable
comp	Component number for vector of coupled scalar variables

Returns: Reference to a GenericVariableValue for the coupled scalar variable

◆ coupledGenericScalarValue() [2/3]

template<>

const GenericVariableValue<false>& ScalarCoupleable::coupledGenericScalarValue	(	const std::string &	var_name,
		const unsigned int	comp
	)		const

protectedinherited

Definition at line 152 of file ScalarCoupleable.C.

 {
   return coupledScalarValue(var_name, comp);
 }

◆ coupledGenericScalarValue() [3/3]

template<>

const GenericVariableValue<true>& ScalarCoupleable::coupledGenericScalarValue	(	const std::string &	var_name,
		const unsigned int	comp
	)		const

protectedinherited

Definition at line 160 of file ScalarCoupleable.C.

 {
   return adCoupledScalarValue(var_name, comp);
 }

◆ coupledMatrixTagScalarValue()

const VariableValue & ScalarCoupleable::coupledMatrixTagScalarValue	(	const std::string &	var_name,
		TagID	tag,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
tag	Tag ID of coupled matrix;
comp	Component number for vector of coupled variables

Returns: Reference to a VariableValue for the coupled variable

Definition at line 202 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   if (!isCoupledScalar(var_name, comp))
     return *getDefaultValue(var_name);
 
   _sc_coupleable_matrix_tags.insert(tag);
 
   return getScalarVar(var_name, comp)->matrixTagSln(tag);
 }

◆ 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 129 of file PostprocessorInterface.C.

Referenced by FunctionValuePostprocessor::FunctionValuePostprocessor().

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

◆ coupledScalar()

unsigned int ScalarCoupleable::coupledScalar	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the index for a scalar coupled variable by name.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Index of coupled variable

Definition at line 93 of file ScalarCoupleable.C.

Referenced by ParsedODEKernel::ParsedODEKernel().

 {
   checkVar(var_name);
   return getScalarVar(var_name, comp)->number();
 }

◆ coupledScalarComponents()

unsigned int ScalarCoupleable::coupledScalarComponents ( const std::string & var_name ) const

protectedinherited

Return the number of components to the coupled scalar variable.

Parameters

var_name The of the coupled variable

Definition at line 353 of file ScalarCoupleable.C.

 {
   const auto var_name = _sc_parameters.checkForRename(var_name_in);
 
   const auto it = _coupled_scalar_vars.find(var_name);
   if (it != _coupled_scalar_vars.end())
     return it->second.size();
 
   mooseError(_sc_name, ": Trying to get a non-existent variable '", var_name, "'");
 }

◆ coupledScalarDot()

const VariableValue & ScalarCoupleable::coupledScalarDot	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a time derivative VariableValue for the coupled variable

Definition at line 244 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   validateExecutionerType(var_name, "coupledScalarDot");
   return getScalarVar(var_name, comp)->uDot();
 }

◆ coupledScalarDotDot()

const VariableValue & ScalarCoupleable::coupledScalarDotDot	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the second time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a time derivative VariableValue for the coupled variable

Definition at line 260 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   validateExecutionerType(var_name, "coupledScalarDotDot");
   return getScalarVar(var_name, comp)->uDotDot();
 }

◆ coupledScalarDotDotDu()

const VariableValue & ScalarCoupleable::coupledScalarDotDotDu	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Second time derivative of a scalar coupled variable with respect to the coefficients.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Definition at line 292 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   validateExecutionerType(var_name, "coupledScalarDotDotDu");
   return getScalarVar(var_name, comp)->duDotDotDu();
 }

◆ coupledScalarDotDotOld()

const VariableValue & ScalarCoupleable::coupledScalarDotDotOld	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the old second time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a time derivative VariableValue for the coupled variable

Definition at line 276 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   validateExecutionerType(var_name, "coupledScalarDotDotOld");
   return getScalarVar(var_name, comp)->uDotDotOld();
 }

◆ coupledScalarDotDu()

const VariableValue & ScalarCoupleable::coupledScalarDotDu	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Time derivative of a scalar coupled variable with respect to the coefficients.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Definition at line 284 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   validateExecutionerType(var_name, "coupledScalarDotDu");
   return getScalarVar(var_name, comp)->duDotDu();
 }

◆ coupledScalarDotOld()

const VariableValue & ScalarCoupleable::coupledScalarDotOld	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the old time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a time derivative VariableValue for the coupled variable

Definition at line 268 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   validateExecutionerType(var_name, "coupledScalarDotOld");
   return getScalarVar(var_name, comp)->uDotOld();
 }

◆ coupledScalarOrder()

Order ScalarCoupleable::coupledScalarOrder	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the order for a scalar coupled variable by name.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Order of coupled variable

Definition at line 100 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   if (!isCoupledScalar(var_name, comp))
     return _sc_fe_problem.getMaxScalarOrder();
 
   return getScalarVar(var_name, comp)->order();
 }

◆ coupledScalarValue()

const VariableValue & ScalarCoupleable::coupledScalarValue	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a VariableValue for the coupled variable

Definition at line 124 of file ScalarCoupleable.C.

Referenced by ParsedODEKernel::ParsedODEKernel().

 {
   checkVar(var_name);
   if (!isCoupledScalar(var_name, comp))
     return *getDefaultValue(var_name);
 
   auto var = getScalarVar(var_name, comp);
   return _sc_is_implicit ? var->sln() : var->slnOld();
 }

◆ coupledScalarValueOld()

const VariableValue & ScalarCoupleable::coupledScalarValueOld	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the old (previous time step) value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a old VariableValue for the coupled variable

Definition at line 216 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   if (!isCoupledScalar(var_name, comp))
     return *getDefaultValue(var_name);
 
   validateExecutionerType(var_name, "coupledScalarValueOld");
   auto var = getScalarVar(var_name, comp);
   return _sc_is_implicit ? var->slnOld() : var->slnOlder();
 }

◆ coupledScalarValueOlder()

const VariableValue & ScalarCoupleable::coupledScalarValueOlder	(	const std::string &	var_name,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns the older (two time steps previous) value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns: Reference to a older VariableValue for the coupled variable

Definition at line 228 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   if (!isCoupledScalar(var_name, comp))
     return *getDefaultValue(var_name);
 
   validateExecutionerType(var_name, "coupledScalarValueOlder");
   auto var = getScalarVar(var_name, comp);
   if (_sc_is_implicit)
     return var->slnOlder();
   else
     mooseError("Older values not available for explicit schemes");
 }

◆ coupledVectorTagScalarValue()

const VariableValue & ScalarCoupleable::coupledVectorTagScalarValue	(	const std::string &	var_name,
		TagID	tag,
		unsigned int	comp = `0`
	)		const

protectedinherited

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
tag	Tag ID of coupled vector ;
comp	Component number for vector of coupled variables

Returns: Reference to a VariableValue for the coupled variable

Definition at line 181 of file ScalarCoupleable.C.

 {
   checkVar(var_name);
   if (!isCoupledScalar(var_name, comp))
     return *getDefaultValue(var_name);
 
   if (!_sc_fe_problem.vectorTagExists(tag))
     mooseError("Attempting to couple to vector tag scalar with ID ",
                tag,
                "in ",
                _sc_name,
                ", but a vector tag with that ID does not exist");
 
   _sc_coupleable_vector_tags.insert(tag);
 
   return getScalarVar(var_name, comp)->vectorTagSln(tag);
 }

◆ declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext	(	const std::string &	data_name,
		void *	context,
		Args &&...	args
	)

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 276 of file Restartable.h.

 {
   auto & data_ptr =
       declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
   return Restartable::ManagedValue<T>(data_ptr);
 }

◆ declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData	(	const std::string &	data_name,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "recoverable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 351 of file Restartable.h.

 {
   const auto full_name = restartableName(data_name);
 
   registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
   return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
 }

◆ declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData	(	const std::string &	data_name,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 269 of file Restartable.h.

 {
   return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
 }

◆ declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext	(	const std::string &	data_name,
		void *	context,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 294 of file Restartable.h.

 {
   return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
 }

◆ declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName	(	const std::string &	data_name,
		const std::string &	object_name,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
args	Arguments to forward to the constructor of the data

Definition at line 323 of file Restartable.h.

 {
   return declareRestartableDataWithObjectNameWithContext<T>(
       data_name, object_name, nullptr, std::forward<Args>(args)...);
 }

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext	(	const std::string &	data_name,
		const std::string &	object_name,
		void *	context,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 333 of file Restartable.h.

 {
   std::string old_name = _restartable_name;
 
   _restartable_name = object_name;
 
   T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
 
   _restartable_name = old_name;
 
   return value;
 }

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 40 of file MooseObject.h.

Referenced by EigenKernel::enabled().

40 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition: MooseObject.h:51

◆ errorPrefix()

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

inherited

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

Definition at line 43 of file MooseBase.C.

Referenced by MooseBase::callMooseError(), MooseBaseErrorInterface::mooseDeprecated(), MooseBaseErrorInterface::mooseInfo(), MooseBaseErrorInterface::mooseWarning(), and MooseBaseParameterInterface::paramErrorMsg().

 {
   std::stringstream oss;
   if (const auto node = _params.getHitNode())
     if (!node->isRoot())
       oss << node->fileLocation() << ":\n";
   oss << "The following " << error_type << " occurred in the ";
   if (const auto base_ptr = _params.getBase())
     oss << *base_ptr;
   else
     oss << "object";
   oss << " '" << name() << "' of type " << type() << ".\n\n";
   return oss.str();
 }

◆ forceNumSteps()

void TimeStepper::forceNumSteps ( const unsigned int num_steps )

virtualinherited

Set the number of time steps.

Parameters

num_steps number of time steps

Definition at line 222 of file TimeStepper.C.

 {
   _executioner.forceNumSteps(num_steps);
 }

◆ forceTimeStep()

void TimeStepper::forceTimeStep ( Real dt )

virtualinherited

Definition at line 216 of file TimeStepper.C.

 {
   _current_dt = dt;
 }

◆ getCheckedPointerParam()

template<typename T >

T MooseBaseParameterInterface::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 286 of file MooseBaseParameterInterface.h.

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

◆ getCoupledMooseScalarVars()

const std::vector<MooseVariableScalar *>& ScalarCoupleable::getCoupledMooseScalarVars ( )

inlineinherited

Get the list of coupled scalar variables.

Returns: The list of coupled variables

Definition at line 45 of file ScalarCoupleable.h.

Referenced by AuxScalarKernel::AuxScalarKernel(), MortarScalarBase::computeJacobian(), and ScalarInitialCondition::ScalarInitialCondition().

   {
     return _coupled_moose_scalar_vars;
   }

◆ getCurrentDT()

Real TimeStepper::getCurrentDT ( )

inlineinherited

Get the current_dt.

Definition at line 85 of file TimeStepper.h.

Referenced by ConstantDT::computeDT(), LogConstantDT::computeDT(), SolutionTimeAdaptiveDT::computeDT(), and TransientBase::getDT().

85 { return _current_dt; }

TimeStepper::_current_dt

Real & _current_dt

Size of the current time step as computed by the Stepper. Note that the actual dt that was taken migh...

Definition: TimeStepper.h:156

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

Referenced by DataFileInterface::getDataFileNameByName().

 {
   // 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.");
 
   // Throw on error so that if getPath() fails, we can throw an error
   // with the context of _parent.mooseError()
   const auto throw_on_error_before = Moose::_throw_on_error;
   Moose::_throw_on_error = true;
   std::optional<std::string> error;
 
   // This will search the data paths for this relative path
   Moose::DataFileUtils::Path found_path;
   try
   {
     found_path = Moose::DataFileUtils::getPath(relative_path);
   }
   catch (std::exception & e)
   {
     error = e.what();
   }
 
   Moose::_throw_on_error = throw_on_error_before;
   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;
 }

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 45 of file MooseBase.h.

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), MooseBaseParameterInterface::connectControllableParams(), Coupleable::Coupleable(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

45 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:84

◆ getParam() [1/2]

template<typename T >

const T & MooseBaseParameterInterface::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 215 of file MooseBaseParameterInterface.h.

 {
   return InputParameters::getParamHelper(name, _pars, static_cast<T *>(0), &_moose_base);
 }

◆ getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBaseParameterInterface::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 279 of file MooseBaseParameterInterface.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 185 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

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

◆ 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 36 of file PostprocessorInterface.C.

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

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

◆ 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 57 of file PostprocessorInterface.C.

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

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

◆ getPostprocessorValueOld()

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

inherited

Definition at line 43 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 63 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

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

◆ getPostprocessorValueOlder()

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

inherited

Definition at line 50 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 69 of file PostprocessorInterface.C.

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

◆ getRenamedParam()

template<typename T >

const T & MooseBaseParameterInterface::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 229 of file MooseBaseParameterInterface.h.

 {
   // this enables having a default on the new parameter but bypassing it with the old one
   // Most important: accept new parameter
   if (isParamSetByUser(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Second most: accept old parameter
   else if (isParamValid(old_name) && !isParamSetByUser(new_name))
     return InputParameters::getParamHelper(old_name, _pars, static_cast<T *>(0), &_moose_base);
   // Third most: accept default for new parameter
   else if (isParamValid(new_name) && !isParamValid(old_name))
     return InputParameters::getParamHelper(new_name, _pars, static_cast<T *>(0), &_moose_base);
   // Refuse: no default, no value passed
   else if (!isParamValid(old_name) && !isParamValid(new_name))
     mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
                "' is being retrieved without being set.\n"
                "Did you misspell it?");
   // Refuse: both old and new parameters set by user
   else
     mooseError(_pars.blockFullpath() + ": parameter '" + new_name +
                "' may not be provided alongside former parameter '" + old_name + "'");
 }

◆ getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string & data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

NOTE: This returns a const reference! Make sure you store it in a const reference!

Parameters

data_name The name of the data (usually just use the same name as the member variable)

Definition at line 287 of file Restartable.h.

 {
   return declareRestartableDataHelper<T>(data_name, nullptr).get();
 }

◆ getScalarVar()

const MooseVariableScalar * ScalarCoupleable::getScalarVar	(	const std::string &	var_name,
		unsigned int	comp
	)		const

protectedinherited

Extract pointer to a scalar coupled variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns: Pointer to the desired variable

Definition at line 321 of file ScalarCoupleable.C.

 {
   const auto var_name = _sc_parameters.checkForRename(var_name_in);
 
   const auto it = _coupled_scalar_vars.find(var_name);
   if (it != _coupled_scalar_vars.end())
   {
     const auto & entry = it->second;
     if (comp < entry.size())
       return entry[comp];
     else
       mooseError(_sc_name, ": Trying to get a non-existent component of variable '", var_name, "'");
   }
   else
     mooseError(_sc_name, ": Trying to get a non-existent variable '", var_name, "'");
 }

◆ getScalarVariableCoupleableMatrixTags()

const std::set<TagID>& ScalarCoupleable::getScalarVariableCoupleableMatrixTags ( ) const

inlineinherited

Definition at line 55 of file ScalarCoupleable.h.

   {
     return _sc_coupleable_matrix_tags;
   }

◆ getScalarVariableCoupleableVectorTags()

const std::set<TagID>& ScalarCoupleable::getScalarVariableCoupleableVectorTags ( ) const

inlineinherited

Definition at line 50 of file ScalarCoupleable.h.

   {
     return _sc_coupleable_vector_tags;
   }

◆ 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 68 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), and MFEMProblem::addMFEMSolver().

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

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 81 of file MooseObject.C.

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

◆ 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 107 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 118 of file PostprocessorInterface.C.

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

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

◆ init()

void IterationAdaptiveDT::init ( )

overridevirtual

Initialize the time stepper.

Called at the very beginning of Executioner::execute()

Reimplemented from TimeStepper.

Definition at line 173 of file IterationAdaptiveDT.C.

 {
   if (isParamValid("timestep_limiting_function"))
   {
     std::set<Real> times;
 
     const auto tid = isParamValid("_tid") ? getParam<THREAD_ID>("_tid") : 0;
     for (const auto & name : getParam<std::vector<FunctionName>>("timestep_limiting_function"))
     {
       const auto * func = &_fe_problem.getFunction(name, tid);
       _timestep_limiting_functions.push_back(func);
 
       const auto * pfunc = dynamic_cast<const PiecewiseBase *>(func);
       _piecewise_timestep_limiting_functions.push_back(pfunc);
 
       if (pfunc)
       {
         const auto * plfunc = dynamic_cast<const PiecewiseLinear *>(pfunc);
         _piecewise_linear_timestep_limiting_functions.push_back(plfunc);
 
         const auto ntimes = pfunc->functionSize();
         for (unsigned int i = 0; i < ntimes; ++i)
           times.insert(pfunc->domain(i));
       }
       else
         mooseError("timestep_limiting_function must be a PiecewiseBase function");
     }
     _times.resize(times.size());
     std::copy(times.begin(), times.end(), _times.begin());
 
     mooseAssert(_timestep_limiting_functions.size() ==
                     _piecewise_timestep_limiting_functions.size(),
                 "Timestep limiting function count inconsistency");
     mooseAssert(_piecewise_timestep_limiting_functions.size() ==
                     _piecewise_linear_timestep_limiting_functions.size(),
                 "Timestep limiting function count inconsistency");
   }
 }

◆ isCoupledScalar()

bool ScalarCoupleable::isCoupledScalar	(	const std::string &	var_name,
		unsigned int	i = `0`
	)		const

protectedinherited

Returns true if a variables has been coupled_as name.

Parameters

var_name	The of the coupled variable
i	By default 0, in general the index to test in a vector of MooseVariable pointers.

Definition at line 70 of file ScalarCoupleable.C.

Referenced by ScalarCoupleable::adCoupledScalarValue(), ScalarCoupleable::coupledMatrixTagScalarValue(), ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::coupledScalarValue(), ScalarCoupleable::coupledScalarValueOld(), ScalarCoupleable::coupledScalarValueOlder(), and ScalarCoupleable::coupledVectorTagScalarValue().

 {
   const auto var_name = _sc_parameters.checkForRename(var_name_in);
 
   auto it = _coupled_scalar_vars.find(var_name);
   if (it != _coupled_scalar_vars.end())
     return (i < it->second.size());
   else
   {
     // Make sure the user originally requested this value in the InputParameter syntax
     if (!_sc_parameters.hasCoupledValue(var_name))
       mooseError(_sc_name,
                  ": The coupled scalar variable \"",
                  var_name,
                  "\" was never added to this object's "
                  "InputParameters, please double-check "
                  "your spelling");
 
     return false;
   }
 }

◆ 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 75 of file PostprocessorInterface.C.

Referenced by EigenKernel::EigenKernel().

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

◆ isParamSetByUser()

bool MooseBaseParameterInterface::isParamSetByUser ( const std::string & nm ) const

inlineinherited

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

Parameters

nm	The name of the parameter to test

Definition at line 128 of file MooseBaseParameterInterface.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), DiffusionPhysicsBase::DiffusionPhysicsBase(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), MooseBaseParameterInterface::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MFEMSolverBase::setPreconditioner(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

128 { return _pars.isParamSetByUser(nm); }

InputParameters::isParamSetByUser

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

Method returns true if the parameter was set by the user.

Definition: InputParameters.C:1178

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:173

◆ isParamValid()

bool MooseBaseParameterInterface::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 122 of file MooseBaseParameterInterface.h.

122 { return _pars.isParamValid(name); }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:173

InputParameters::isParamValid

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

This method returns parameters that have been initialized in one fashion or another, i.e.

Definition: InputParameters.C:390

◆ limitDTByFunction()

void IterationAdaptiveDT::limitDTByFunction ( Real & limitedDT )

protected

Definition at line 424 of file IterationAdaptiveDT.C.

Referenced by constrainStep().

 {
   Real orig_dt = limitedDT;
   const auto nfunc = _timestep_limiting_functions.size();
   Real restricted_step = std::numeric_limits<Real>::max();
 
   for (unsigned int j = 0; j < nfunc; ++j)
   {
     // Limit by function change for piecewise linear functions.
     if (_piecewise_linear_timestep_limiting_functions[j] && _max_function_change > 0)
     {
       const auto current_function_value =
           _piecewise_linear_timestep_limiting_functions[j]->value(_time, {});
 
       const auto ntimes = _piecewise_linear_timestep_limiting_functions[j]->functionSize();
       for (std::size_t next_time_index = 1; next_time_index < ntimes; ++next_time_index)
       {
         const auto next_time =
             _piecewise_linear_timestep_limiting_functions[j]->domain(next_time_index);
 
         // Skip ahead to find time point that is just past the current time.
         if (next_time + _timestep_tolerance <= _time)
           continue;
 
         // Find out how far we can go without exceeding the max function change.
         const auto next_function_value =
             _piecewise_linear_timestep_limiting_functions[j]->range(next_time_index);
         const auto change = std::abs(next_function_value - current_function_value);
         if (change > _max_function_change)
         {
           // Interpolate to find step.
           restricted_step =
               std::min(restricted_step, (_max_function_change / change) * (next_time - _time));
           break;
         }
 
         // Don't keep going if we've already passed the current limited step.
         if (next_time > _time + limitedDT)
           break;
       }
     }
     else if (_timestep_limiting_functions[j])
     {
       const Real old_value = _timestep_limiting_functions[j]->value(_time_old);
       Real new_value = _timestep_limiting_functions[j]->value(_time_old + limitedDT);
       Real change = std::abs(new_value - old_value);
 
       if (_max_function_change > 0.0 && change > _max_function_change)
         do
         {
           limitedDT /= 2.0;
           new_value = _timestep_limiting_functions[j]->value(_time_old + limitedDT);
           change = std::abs(new_value - old_value);
         } while (change > _max_function_change);
     }
   }
 
   if (restricted_step < limitedDT)
     limitedDT = std::max(_dt_min, restricted_step);
 
   _at_function_point = false;
   if (_force_step_every_function_point)
     for (unsigned int i = 0; i + 1 < _times.size(); ++i)
       if (_time >= _times[i] && _time < _times[i + 1])
       {
         if (limitedDT > _times[i + 1] - _time - _timestep_tolerance)
         {
           limitedDT = _times[i + 1] - _time;
           _at_function_point = true;
         }
         break;
       }
 
   if (_verbose && limitedDT != orig_dt)
   {
     if (_at_function_point)
       _console << "Limiting dt to match function point. dt = ";
     else
       _console << "Limiting dt to limit change in function. dt = ";
 
     _console << limitedDT << std::endl;
   }
 }

◆ limitDTToPostprocessorValue()

void IterationAdaptiveDT::limitDTToPostprocessorValue ( Real & limitedDT ) const

protected

Definition at line 395 of file IterationAdaptiveDT.C.

Referenced by constrainStep(), and converged().

 {
   if (_pps_value.size() != 0 && _t_step > 1)
   {
     Real limiting_pps_value = *_pps_value[0];
     unsigned int i_min = 0;
     for (size_t i = 1; i < _pps_value.size(); ++i)
       if (*_pps_value[i] < limiting_pps_value)
       {
         limiting_pps_value = *_pps_value[i];
         i_min = i;
       }
 
     if (limitedDT > limiting_pps_value)
     {
       if (limiting_pps_value < 0)
         mooseWarning(
             "Negative timestep limiting postprocessor '" +
             getParam<std::vector<PostprocessorName>>("timestep_limiting_postprocessor")[i_min] +
             "': " + std::to_string(limiting_pps_value));
       limitedDT = std::max(_dt_min, limiting_pps_value);
 
       if (_verbose)
         _console << "Limiting dt to postprocessor value. dt = " << limitedDT << std::endl;
     }
   }
 }

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 91 of file MooseBaseErrorInterface.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), and UserForcingFunction::UserForcingFunction().

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

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Emits a documented error with object name and type.

Documented errors are errors that have an issue associated with them.

The repository name repo_name links a named repository to a URL and should be registered at the application level with registerRepository(). See Moose.C for an example of the "moose" repository registration.

Parameters

repo_name	The repository name where the issue resides
issue_num	The number of the issue
args	The error message to be combined

Definition at line 61 of file MooseBaseErrorInterface.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     const auto msg = moose::internal::formatMooseDocumentedError(repo_name, issue_num, oss.str());
     _moose_base.callMooseError(msg, /* with_prefix = */ true);
   }

◆ mooseError()

template<typename... Args>

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

inlineinherited

Emits an error prefixed with object name and type.

Definition at line 29 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ true);
   }

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 40 of file MooseBaseErrorInterface.h.

   {
     std::ostringstream oss;
     moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
     _moose_base.callMooseError(oss.str(), /* with_prefix = */ false);
   }

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 98 of file MooseBaseErrorInterface.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MFEMScalarFESpace::getFECName(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), SolutionUserObjectBase::SolutionUserObjectBase(), and SymmetryTransformGenerator::SymmetryTransformGenerator().

   {
     moose::internal::mooseInfoStream(
         _console, _moose_base.errorPrefix("information"), std::forward<Args>(args)...);
   }

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 75 of file MooseBaseErrorInterface.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchedMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), DataFileInterface::getDataFilePath(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), CartesianGridDivision::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), limitDTToPostprocessorValue(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

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

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 85 of file MooseBaseErrorInterface.h.

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

◆ name()

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

inlinevirtualinherited

Get the name of the class.

Returns: The name of the class

Reimplemented in MooseVariableBase.

Definition at line 57 of file MooseBase.h.

57 { return _name; }

MooseBase::_name

const std::string _name

The name of this class.

Definition: MooseBase.h:90

◆ numFailures()

unsigned int TimeStepper::numFailures ( ) const

inherited

Gets the number of failures and returns them.

Definition at line 191 of file TimeStepper.C.

Referenced by NumFailedTimeSteps::getValue().

 {
   return _failure_count;
 }

◆ paramError()

template<typename... Args>

void MooseBaseParameterInterface::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 255 of file MooseBaseParameterInterface.h.

 {
   Moose::show_trace = false;
   _moose_base.callMooseError(paramErrorMsg(param, std::forward<Args>(args)...),
                              /* with_prefix = */ false);
   Moose::show_trace = true;
 }

◆ parameters()

const InputParameters& MooseBaseParameterInterface::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 62 of file MooseBaseParameterInterface.h.

62 { return _pars; }

MooseBaseParameterInterface::_pars

const InputParameters & _pars

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition: MooseBaseParameterInterface.h:173

◆ paramInfo()

template<typename... Args>

void MooseBaseParameterInterface::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 272 of file MooseBaseParameterInterface.h.

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

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

◆ paramWarning()

template<typename... Args>

void MooseBaseParameterInterface::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 265 of file MooseBaseParameterInterface.h.

Referenced by GridPartitioner::_do_partition(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

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

◆ postExecute()

virtual void TimeStepper::postExecute ( )

inlinevirtualinherited

Reimplemented in CompositionDT.

Definition at line 38 of file TimeStepper.h.

Referenced by TransientBase::postExecute().

38 {}

◆ postSolve()

virtual void TimeStepper::postSolve ( )

inlinevirtualinherited

Reimplemented in CompositionDT, and AB2PredictorCorrector.

Definition at line 37 of file TimeStepper.h.

Referenced by TransientBase::takeStep().

37 {}

◆ postStep()

virtual void TimeStepper::postStep ( )

inlinevirtualinherited

Reimplemented in CompositionDT, and FunctionDT.

Definition at line 40 of file TimeStepper.h.

Referenced by TransientBase::postStep().

40 {}

◆ preExecute()

void IterationAdaptiveDT::preExecute ( )

overridevirtual

Reimplemented from TimeStepper.

Definition at line 213 of file IterationAdaptiveDT.C.

 {
   TimeStepper::preExecute();
 
   // Delete all tfunc times that are at or before the begin time
   while (!_tfunc_times.empty() && _time + _timestep_tolerance >= *_tfunc_times.begin())
     _tfunc_times.erase(_tfunc_times.begin());
 }

◆ preSolve()

virtual void TimeStepper::preSolve ( )

inlinevirtualinherited

Reimplemented in CompositionDT, and AB2PredictorCorrector.

Definition at line 36 of file TimeStepper.h.

Referenced by TransientBase::takeStep().

36 {}

◆ preStep()

virtual void TimeStepper::preStep ( )

inlinevirtualinherited

Reimplemented in CompositionDT.

Definition at line 39 of file TimeStepper.h.

Referenced by TransientBase::preStep().

39 {}

◆ queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

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 222 of file MooseBaseParameterInterface.h.

 {
   return isParamValid(name) ? &getParam<T>(name) : nullptr;
 }

◆ rejectStep()

void IterationAdaptiveDT::rejectStep ( )

overridevirtual

This gets called when time step is rejected.

Reimplemented from TimeStepper.

Definition at line 565 of file IterationAdaptiveDT.C.

 {
   TimeStepper::rejectStep();
 }

◆ restartableName()

std::string Restartable::restartableName ( const std::string & data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 66 of file Restartable.C.

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

 {
   return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
 }

◆ step()

void TimeStepper::step ( )

virtualinherited

Take a time step.

Reimplemented in CompositionDT, AB2PredictorCorrector, TimeSequenceStepperBase, SolutionTimeAdaptiveDT, and TimeSequenceFromTimes.

Definition at line 166 of file TimeStepper.C.

Referenced by SolutionTimeAdaptiveDT::step(), TimeSequenceStepperBase::step(), CompositionDT::step(), and TransientBase::takeStep().

 {
   _converged = _executioner.timeStepSolveObject()->solve();
 
   if (!_converged)
     _failure_count++;
 }

◆ 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 51 of file MooseBase.h.

51 { return _type; }

MooseBase::_type

const std::string _type

The type of this class.

Definition: MooseBase.h:87

◆ 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 27 of file MooseBase.C.

Referenced by MaterialPropertyStorage::addProperty(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

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

◆ uniqueName()

MooseObjectName MooseBaseParameterInterface::uniqueName ( ) const

inlineinherited

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

Definition at line 67 of file MooseBaseParameterInterface.h.

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

   {
     return MooseObjectName(_pars.get<std::string>("_unique_name"));
   }

◆ uniqueParameterName()

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

inlineinherited

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

Definition at line 52 of file MooseBaseParameterInterface.h.

   {
     return MooseObjectParameterName(
         _pars.get<std::string>("_moose_base"), _moose_base.name(), parameter_name);
   }

◆ validParams()

InputParameters IterationAdaptiveDT::validParams ( )

static

Definition at line 25 of file IterationAdaptiveDT.C.

 {
   InputParameters params = TimeStepper::validParams();
   params.addClassDescription("Adjust the timestep based on the number of iterations");
   params.addParam<int>(
       "optimal_iterations",
       "The target number of solver outer iterations for adaptive timestepping. "
       "For a problem using nonlinear systems, the total number of nonlinear iterations is used. "
       "For a problem using linear systems, the total number of linear iterations is used.");
   params.addParam<int>("iteration_window",
                        "Attempt to grow/shrink timestep if the iteration count "
                        "is below/above 'optimal_iterations plus/minus "
                        "iteration_window' (default = optimal_iterations/5).");
   params.addParam<unsigned>("linear_iteration_ratio",
                             "The ratio of linear to nonlinear iterations "
                             "to determine target linear iterations and "
                             "window for adaptive timestepping (default = "
                             "25)");
   params.addParam<std::vector<PostprocessorName>>("timestep_limiting_postprocessor",
                                                   "If specified, a list of postprocessor values "
                                                   "used as an upper limit for the "
                                                   "current time step length");
   params.addParam<std::vector<FunctionName>>(
       "timestep_limiting_function",
       "A list of 'PiecewiseBase' type functions used to control the timestep by "
       "limiting the change in the function over a timestep");
   params.addParam<Real>(
       "max_function_change",
       "The absolute value of the maximum change in timestep_limiting_function over a timestep");
   params.addParam<bool>("force_step_every_function_point",
                         false,
                         "Forces the timestepper to take "
                         "a step that is consistent with "
                         "points defined in the function");
   params.addRangeCheckedParam<Real>(
       "post_function_sync_dt",
       "post_function_sync_dt>0",
       "Timestep to apply after time sync with function point. To be used in "
       "conjunction with 'force_step_every_function_point'.");
   params.addRequiredParam<Real>("dt", "The default timestep size between solves");
   params.addParam<std::vector<Real>>("time_t", {}, "The values of t");
   params.addParam<std::vector<Real>>("time_dt", {}, "The values of dt");
   params.addParam<Real>("growth_factor",
                         2.0,
                         "Factor to apply to timestep if easy convergence (if "
                         "'optimal_iterations' is specified) or if recovering "
                         "from failed solve");
   params.addParam<Real>("cutback_factor",
                         0.5,
                         "Factor to apply to timestep if difficult convergence "
                         "occurs (if 'optimal_iterations' is specified). "
                         "For failed solves, use cutback_factor_at_failure");
 
   params.addParam<bool>("reject_large_step",
                         false,
                         "If 'true', time steps that are too large compared to the "
                         "ideal time step will be rejected and repeated");
   params.addRangeCheckedParam<Real>("reject_large_step_threshold",
                                     0.1,
                                     "reject_large_step_threshold > 0 "
                                     "& reject_large_step_threshold < 1",
                                     "Ratio between the the ideal time step size and the "
                                     "current time step size below which a time step will "
                                     "be rejected if 'reject_large_step' is 'true'");
 
   params.declareControllable("growth_factor cutback_factor");
 
   return params;
 }

Member Data Documentation

◆ _action_factory

ActionFactory& MooseBaseParameterInterface::_action_factory

protectedinherited

Builds Actions.

Definition at line 179 of file MooseBaseParameterInterface.h.

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

◆ _adaptive_timestepping

bool IterationAdaptiveDT::_adaptive_timestepping

protected

adaptive timestepping is active if the optimal_iterations input parameter is specified

Definition at line 73 of file IterationAdaptiveDT.h.

Referenced by computeDT(), and IterationAdaptiveDT().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 84 of file MooseBase.h.

◆ _at_function_point

bool IterationAdaptiveDT::_at_function_point

protected

Definition at line 114 of file IterationAdaptiveDT.h.

Referenced by acceptStep(), and limitDTByFunction().

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

◆ _converged

bool TimeStepper::_converged

protectedinherited

Whether or not the previous solve converged.

Definition at line 140 of file TimeStepper.h.

Referenced by AB2PredictorCorrector::converged(), TimeStepper::converged(), AB2PredictorCorrector::step(), and TimeStepper::step().

◆ _cutback_factor

const Real& IterationAdaptiveDT::_cutback_factor

protected

cut the timestep by by this factor

Definition at line 101 of file IterationAdaptiveDT.h.

Referenced by computeAdaptiveDT().

◆ _cutback_factor_at_failure

const Real TimeStepper::_cutback_factor_at_failure

protectedinherited

Cutback factor if a time step fails to converge.

Definition at line 143 of file TimeStepper.h.

Referenced by TimeSequenceStepperBase::computeFailedDT(), computeFailedDT(), and TimeStepper::computeFailedDT().

◆ _cutback_occurred

bool& IterationAdaptiveDT::_cutback_occurred

protected

Definition at line 113 of file IterationAdaptiveDT.h.

Referenced by computeDT(), and computeFailedDT().

◆ _dt

Real& TimeStepper::_dt

protectedinherited

Definition at line 128 of file TimeStepper.h.

Referenced by FixedPointIterationAdaptiveDT::acceptStep(), acceptStep(), FunctionDT::computeDT(), SolutionTimeAdaptiveDT::computeDT(), AB2PredictorCorrector::computeDT(), computeFailedDT(), TimeStepper::computeFailedDT(), converged(), AB2PredictorCorrector::estimateTimeError(), AB2PredictorCorrector::preSolve(), and SolutionTimeAdaptiveDT::step().

◆ _dt_from_reject

std::optional<Real> IterationAdaptiveDT::_dt_from_reject

mutableprotected

Timestep used to reject a timestep, used to constrain the next attempt.

Definition at line 121 of file IterationAdaptiveDT.h.

Referenced by constrainStep(), and converged().

◆ _dt_max

Real& TimeStepper::_dt_max

protectedinherited

Definition at line 130 of file TimeStepper.h.

Referenced by SolutionTimeAdaptiveDT::computeDT(), and TimeStepper::constrainStep().

◆ _dt_min

Real& TimeStepper::_dt_min

protectedinherited

Definition at line 129 of file TimeStepper.h.

Referenced by TimeSequenceStepperBase::computeFailedDT(), computeFailedDT(), TimeStepper::computeFailedDT(), TimeStepper::constrainStep(), converged(), CompositionDT::getSequenceSteppersNextTime(), limitDTByFunction(), and limitDTToPostprocessorValue().

◆ _dt_old

Real& IterationAdaptiveDT::_dt_old

protected

Definition at line 58 of file IterationAdaptiveDT.h.

Referenced by acceptStep(), computeAdaptiveDT(), computeDT(), and computeInterpolationDT().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 51 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _end_time

Real& TimeStepper::_end_time

protectedinherited

Definition at line 131 of file TimeStepper.h.

Referenced by TimeStepper::constrainStep().

◆ _executioner

TransientBase& TimeStepper::_executioner

protectedinherited

Reference to transient executioner.

Definition at line 122 of file TimeStepper.h.

Referenced by FixedPointIterationAdaptiveDT::acceptStep(), acceptStep(), computeDT(), TimeStepper::forceNumSteps(), TimeSequenceStepperBase::setupSequence(), TimeSequenceStepperBase::step(), and TimeStepper::step().

◆ _factory

Factory& MooseBaseParameterInterface::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 176 of file MooseBaseParameterInterface.h.

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

◆ _failure_count

unsigned int TimeStepper::_failure_count

protectedinherited

Cumulative amount of steps that have failed.

Definition at line 152 of file TimeStepper.h.

Referenced by TimeStepper::numFailures(), TimeStepper::step(), and CompositionDT::step().

◆ _fe_problem

FEProblemBase& TimeStepper::_fe_problem

protectedinherited

Definition at line 120 of file TimeStepper.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), acceptStep(), computeAdaptiveDT(), AB2PredictorCorrector::estimateTimeError(), CompositionDT::getTimeSteppers(), FixedPointIterationAdaptiveDT::init(), init(), TimeStepper::rejectStep(), and AB2PredictorCorrector::step().

◆ _force_step_every_function_point

const bool IterationAdaptiveDT::_force_step_every_function_point

protected

insert sync points at the time nodes of the _piecewise_timestep_limiting_function

Definition at line 87 of file IterationAdaptiveDT.h.

Referenced by IterationAdaptiveDT(), and limitDTByFunction().

◆ _growth_factor

const Real& IterationAdaptiveDT::_growth_factor

protected

grow the timestep by this factor

Definition at line 99 of file IterationAdaptiveDT.h.

Referenced by computeAdaptiveDT(), computeDT(), and computeInterpolationDT().

◆ _has_reset_dt

bool TimeStepper::_has_reset_dt

protectedinherited

True if dt has been reset.

Definition at line 149 of file TimeStepper.h.

Referenced by TimeStepper::computeStep().

◆ _input_dt

const Real IterationAdaptiveDT::_input_dt

protected

The dt from the input file.

Definition at line 61 of file IterationAdaptiveDT.h.

Referenced by computeInitialDT().

◆ _iteration_window

int IterationAdaptiveDT::_iteration_window

protected

...plus/minus this value.

Definition at line 69 of file IterationAdaptiveDT.h.

Referenced by computeAdaptiveDT(), and IterationAdaptiveDT().

◆ _l_its

unsigned int& IterationAdaptiveDT::_l_its

protected

Number of linear iterations in previous solve.

Definition at line 111 of file IterationAdaptiveDT.h.

Referenced by acceptStep(), and computeAdaptiveDT().

◆ _large_step_rejection_threshold

double IterationAdaptiveDT::_large_step_rejection_threshold

protected

Threshold used to detect whether we need to reject a step.

Definition at line 119 of file IterationAdaptiveDT.h.

Referenced by converged().

◆ _linear_iteration_ratio

const int IterationAdaptiveDT::_linear_iteration_ratio

protected

use _optimal_iterations and _iteration_window multiplied with this factor for linear iterations

Definition at line 71 of file IterationAdaptiveDT.h.

Referenced by computeAdaptiveDT().

◆ _max_function_change

Real IterationAdaptiveDT::_max_function_change

protected

Definition at line 85 of file IterationAdaptiveDT.h.

Referenced by IterationAdaptiveDT(), and limitDTByFunction().

◆ _name

const std::string MooseBase::_name

protectedinherited

The name of this class.

Definition at line 90 of file MooseBase.h.

◆ _nl_its

unsigned int& IterationAdaptiveDT::_nl_its

protected

Definition at line 109 of file IterationAdaptiveDT.h.

◆ _optimal_iterations

int IterationAdaptiveDT::_optimal_iterations

protected

Adapt the timestep to maintain this non-linear iteration count...

Definition at line 67 of file IterationAdaptiveDT.h.

Referenced by computeAdaptiveDT(), and IterationAdaptiveDT().

◆ _outer_its

unsigned int& IterationAdaptiveDT::_outer_its

protected

Number of outer solver iterations in previous solve.

For a single nonlinear system: number of nonlinear iterations For a linear system: number of linear iterations For multiple systems: sum of the number of iterations of each system

Definition at line 107 of file IterationAdaptiveDT.h.

Referenced by acceptStep(), and computeAdaptiveDT().

◆ _pars

const InputParameters& MooseBaseParameterInterface::_pars

protectedinherited

Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.

Definition at line 173 of file MooseBaseParameterInterface.h.

◆ _piecewise_linear_timestep_limiting_functions

std::vector<const PiecewiseLinear *> IterationAdaptiveDT::_piecewise_linear_timestep_limiting_functions

protected

Definition at line 80 of file IterationAdaptiveDT.h.

Referenced by init(), and limitDTByFunction().

◆ _piecewise_timestep_limiting_functions

std::vector<const PiecewiseBase *> IterationAdaptiveDT::_piecewise_timestep_limiting_functions

protected

Definition at line 79 of file IterationAdaptiveDT.h.

Referenced by init().

◆ _point_zero

const Point& ScalarCoupleable::_point_zero

protectedinherited

Zero point.

Definition at line 244 of file ScalarCoupleable.h.

Referenced by FunctionDT::computeDT(), FunctionScalarAux::computeValue(), and FunctionScalarIC::value().

◆ _post_function_sync_dt

const Real IterationAdaptiveDT::_post_function_sync_dt

protected

Set timestep size if previous timestep is synced with function.

Definition at line 89 of file IterationAdaptiveDT.h.

Referenced by computeDT().

◆ _pps_value

std::vector<const PostprocessorValue *> IterationAdaptiveDT::_pps_value

protected

if specified, the postprocessor values used to determine an upper limit for the time step length

Definition at line 76 of file IterationAdaptiveDT.h.

Referenced by IterationAdaptiveDT(), and limitDTToPostprocessorValue().

◆ _real_zero

const Real& ScalarCoupleable::_real_zero

protectedinherited

Scalar zero.

Definition at line 238 of file ScalarCoupleable.h.

◆ _reject_large_step

bool IterationAdaptiveDT::_reject_large_step

protected

Indicates whether we need to reject a time step much larger than its ideal size.

Definition at line 117 of file IterationAdaptiveDT.h.

Referenced by converged().

◆ _reset_dt

bool TimeStepper::_reset_dt

protectedinherited

If true then the next dt will be computed by computeInitialDT()

Definition at line 146 of file TimeStepper.h.

Referenced by TimeStepper::computeStep().

◆ _restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 227 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

◆ _restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 236 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 230 of file Restartable.h.

Referenced by Restartable::restartableName().

◆ _restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 233 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

◆ _sc_fe_problem

FEProblemBase& ScalarCoupleable::_sc_fe_problem

protectedinherited

Definition at line 232 of file ScalarCoupleable.h.

Referenced by ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::coupledVectorTagScalarValue(), ScalarCoupleable::getADDefaultValue(), ScalarCoupleable::getDefaultValue(), and ScalarCoupleable::validateExecutionerType().

◆ _sc_tid

const THREAD_ID ScalarCoupleable::_sc_tid

protectedinherited

Thread ID of the thread using this object.

Definition at line 235 of file ScalarCoupleable.h.

Referenced by ScalarCoupleable::ScalarCoupleable().

◆ _scalar_zero

const VariableValue& ScalarCoupleable::_scalar_zero

protectedinherited

Zero value of a scalar variable.

Definition at line 241 of file ScalarCoupleable.h.

◆ _sync_last_step

bool& IterationAdaptiveDT::_sync_last_step

protected

Definition at line 64 of file IterationAdaptiveDT.h.

Referenced by acceptStep(), and computeDT().

◆ _sync_times

std::set<Real>& TimeStepper::_sync_times

protectedinherited

Definition at line 132 of file TimeStepper.h.

Referenced by TimeStepper::acceptStep(), TimeStepper::constrainStep(), and TimeStepper::preExecute().

◆ _t_step

int& TimeStepper::_t_step

protectedinherited

Definition at line 127 of file TimeStepper.h.

Referenced by SolutionTimeAdaptiveDT::computeDT(), AB2PredictorCorrector::computeDT(), TimeStepper::computeStep(), converged(), limitDTToPostprocessorValue(), and AB2PredictorCorrector::step().

◆ _tfunc_last_step

bool& IterationAdaptiveDT::_tfunc_last_step

protected

Definition at line 63 of file IterationAdaptiveDT.h.

Referenced by acceptStep(), computeDT(), and computeInitialDT().

◆ _tfunc_times

std::set<Real> IterationAdaptiveDT::_tfunc_times

protected

Definition at line 91 of file IterationAdaptiveDT.h.

Referenced by acceptStep(), constrainStep(), and preExecute().

◆ _time

Real& TimeStepper::_time

protectedinherited

Values from executioner.

Definition at line 125 of file TimeStepper.h.

Referenced by acceptStep(), TimeStepper::acceptStep(), LogConstantDT::computeDT(), FunctionDT::computeDT(), SolutionTimeAdaptiveDT::computeDT(), constrainStep(), TimeStepper::constrainStep(), CompositionDT::getSequenceSteppersNextTime(), limitDTByFunction(), TimeStepper::preExecute(), preExecute(), CompositionDT::produceCompositionDT(), and FunctionDT::removeOldKnots().

◆ _time_ipol

LinearInterpolation IterationAdaptiveDT::_time_ipol

protected

PiecewiseBase linear definition of time stepping.

Definition at line 94 of file IterationAdaptiveDT.h.

Referenced by computeDT(), computeInitialDT(), and computeInterpolationDT().

◆ _time_old

Real& TimeStepper::_time_old

protectedinherited

Definition at line 126 of file TimeStepper.h.

Referenced by computeDT(), computeInitialDT(), computeInterpolationDT(), and limitDTByFunction().

◆ _times

std::vector<Real> IterationAdaptiveDT::_times

protected

time point defined in the piecewise function

Definition at line 83 of file IterationAdaptiveDT.h.

Referenced by init(), and limitDTByFunction().

◆ _timestep_limiting_functions

std::vector<const Function *> IterationAdaptiveDT::_timestep_limiting_functions

protected

Definition at line 78 of file IterationAdaptiveDT.h.

Referenced by init(), and limitDTByFunction().

◆ _timestep_tolerance

Real& TimeStepper::_timestep_tolerance

protectedinherited

Definition at line 134 of file TimeStepper.h.

Referenced by acceptStep(), TimeStepper::acceptStep(), constrainStep(), TimeStepper::constrainStep(), limitDTByFunction(), TimeStepper::preExecute(), and preExecute().

◆ _type

const std::string MooseBase::_type

protectedinherited

The type of this class.

Definition at line 87 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FillBetweenCurvesGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _use_time_ipol

const bool IterationAdaptiveDT::_use_time_ipol

protected

true if we want to use piecewise-defined time stepping

Definition at line 96 of file IterationAdaptiveDT.h.

Referenced by computeDT().

◆ _verbose

const bool& TimeStepper::_verbose

protectedinherited

whether a detailed diagnostic output should be printed

Definition at line 137 of file TimeStepper.h.

Referenced by acceptStep(), computeAdaptiveDT(), FixedPointIterationAdaptiveDT::computeDT(), computeDT(), computeFailedDT(), computeInitialDT(), computeInterpolationDT(), constrainStep(), TimeStepper::constrainStep(), limitDTByFunction(), and limitDTToPostprocessorValue().

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

include/timesteppers/IterationAdaptiveDT.h
src/timesteppers/IterationAdaptiveDT.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ IterationAdaptiveDT()

Member Function Documentation

◆ acceptStep()

◆ adCoupledScalarDot()

◆ adCoupledScalarValue()

◆ addPostprocessorDependencyHelper()

◆ addSyncTime() [1/2]

◆ addSyncTime() [2/2]

◆ callMooseError()

◆ computeAdaptiveDT()

◆ computeDT()

◆ computeFailedDT()

◆ computeInitialDT()

◆ computeInterpolationDT()

◆ computeStep()

◆ connectControllableParams()

◆ constrainStep()

◆ converged()

◆ coupledGenericScalarValue() [1/3]

◆ coupledGenericScalarValue() [2/3]

◆ coupledGenericScalarValue() [3/3]

◆ coupledMatrixTagScalarValue()

◆ coupledPostprocessors()

◆ coupledScalar()

◆ coupledScalarComponents()

◆ coupledScalarDot()

◆ coupledScalarDotDot()

◆ coupledScalarDotDotDu()

◆ coupledScalarDotDotOld()

◆ coupledScalarDotDu()

◆ coupledScalarDotOld()

◆ coupledScalarOrder()

◆ coupledScalarValue()

◆ coupledScalarValueOld()

◆ coupledScalarValueOlder()

◆ coupledVectorTagScalarValue()

◆ declareManagedRestartableDataWithContext()

◆ declareRecoverableData()

◆ declareRestartableData()

◆ declareRestartableDataWithContext()

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ enabled()

◆ errorPrefix()

◆ forceNumSteps()

◆ forceTimeStep()

◆ getCheckedPointerParam()

◆ getCoupledMooseScalarVars()

◆ getCurrentDT()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getMooseApp()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getPostprocessorName()

◆ getPostprocessorValue()

◆ getPostprocessorValueByName()

◆ getPostprocessorValueOld()

◆ getPostprocessorValueOldByName()

◆ getPostprocessorValueOlder()

◆ getPostprocessorValueOlderByName()

◆ getRenamedParam()

◆ getRestartableData()

◆ getScalarVar()

◆ getScalarVariableCoupleableMatrixTags()

◆ getScalarVariableCoupleableVectorTags()

◆ getSharedPtr() [1/2]

◆ getSharedPtr() [2/2]

◆ hasPostprocessor()