The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system. More...

#include <InputParameters.h>

Inheritance diagram for InputParameters:

Classes
struct	CommandLineMetadata
	Structure for storing information about a command line parameter. More...

class	CommandLineParamSetKey
	Class that is used as a parameter to commandLineParamSet() that allows only the CommandLine to set that a parmeter is set by the command line. More...

struct	isValidCommandLineType
	Determines whether or not the given type is a type that is supported for a command line parameter. More...

struct	Metadata

class	SetHitNodeKey
	Class that is used as a parameter to setHitNode() that allows only relevant classes to set the hit node. More...

class	SetParamHitNodeKey
	Class that is used as a parameter to setHitNode(param) that allows only relevant classes to set the hit node. More...

Public Types
typedef std::map< std::string, std::unique_ptr< Value >, std::less<> >	map_type

typedef map_type::iterator	iterator

typedef map_type::const_iterator	const_iterator

Public Member Functions
	InputParameters (const InputParameters &rhs)

	InputParameters (const Parameters &rhs)

virtual	~InputParameters ()=default

virtual void	clear () override

void	addClassDescription (const std::string &doc_string)
	This method adds a description of the class that will be displayed in the input file syntax dump. More...

std::string	getClassDescription () const
	Returns the class description. More...

virtual void	set_attributes (const std::string &name, bool inserted_only) override
	Override from libMesh to set user-defined attributes on our parameter. More...

bool	attemptPrintDeprecated (const std::string &name)
	Prints the deprecated parameter message, assuming we have the right flags set. More...

template<typename T >
void	setHelper (const std::string &name)
	This functions is called in set as a 'callback' to avoid code duplication. More...

template<typename T >
T &	set (const std::string &name, bool quiet_mode=false)
	Returns a writable reference to the named parameters. More...

template<typename T , typename... Ts>
void	setParameters (const std::string &name, const T &value, Ts... extra_input_parameters)
	Given a series of parameters names and values, sets each name to the corresponding value. More...

template<typename T , typename UP_T >
void	rangeCheck (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, std::ostream &oss=Moose::out)
	Runs a range on the supplied parameter if it exists and throws an error if that check fails. More...

template<typename T , typename UP_T >
void	rangeCheck (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< T >> *param, std::ostream &oss=Moose::out)

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

template<typename T >
void	addRequiredParam (const std::string &name, const std::string &doc_string)
	This method adds a parameter and documentation string to the InputParameters object that will be extracted from the input file. More...

template<typename T >
void	addRequiredParam (const std::string &name, const T &moose_enum, const std::string &doc_string)
	This version of addRequiredParam is here for a consistent use with MooseEnums. More...

template<typename T >
void	addParam (const std::string &name, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)
	Enable support for initializer lists as default arguments for container type. More...

template<typename T >
void	addRequiredCustomTypeParam (const std::string &name, const std::string &custom_type, const std::string &doc_string)
	These methods add an option parameter and with a customer type to the InputParameters object. More...

template<typename T >
void	addCustomTypeParam (const std::string &name, const T &value, const std::string &custom_type, const std::string &doc_string)

template<typename T >
void	addCustomTypeParam (const std::string &name, const std::string &custom_type, const std::string &doc_string)

template<typename T >
void	addDeprecatedCustomTypeParam (const std::string &name, const std::string &custom_type, const std::string &doc_string, const std::string &deprecation_msg)

template<typename T >
void	addPrivateParam (const std::string &name, const T &value)
	These method add a parameter to the InputParameters object which can be retrieved like any other parameter. More...

template<typename T >
void	addPrivateParam (const std::string &name)

template<typename T >
void	addRequiredCommandLineParam (const std::string &name, const std::string &syntax, const std::string &doc_string)
	Add parameters for retrieval from the command line. More...

template<typename T >
void	addCommandLineParam (const std::string &name, const std::string &syntax, const std::string &doc_string)

template<typename T >
void	addCommandLineParam (const std::string &name, const std::string &syntax, const T &value, const std::string &doc_string)

template<typename T >
void	addCommandLineParam (const std::string &name, const std::string &syntax, const std::initializer_list< typename T::value_type > &value, const std::string &doc_string)

template<typename T >
void	addOptionalValuedCommandLineParam (const std::string &name, const std::string &syntax, const T &value, const std::string &doc_string)
	Add a command line parameter with an optional value. More...

void	setGlobalCommandLineParam (const std::string &name)
	Sets the command line parameter with `name` as global. More...

template<typename T >
void	addDeprecatedParam (const std::string &name, const T &value, const std::string &doc_string, const std::string &deprecation_message)

template<typename T >
void	addDeprecatedParam (const std::string &name, const std::string &doc_string, const std::string &deprecation_message)

template<typename T >
void	checkConsistentType (const std::string &name) const
	This method checks to make sure that we aren't adding a parameter with the same name but a different type. More...

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

std::optional< InputParameters::CommandLineMetadata >	queryCommandLineMetadata (const std::string &name) const

const InputParameters::CommandLineMetadata &	getCommandLineMetadata (const std::string &name) const

void	commandLineParamSet (const std::string &name, const CommandLineParamSetKey)
	Marks the command line parameter `name` as set by the CommandLine. More...

const std::string &	getDescription (const std::string &name) const
	Get the documentation string for a parameter. More...

void	addParamNamesToGroup (const std::string &space_delim_names, const std::string group_name)
	This method takes a space delimited list of parameter names and adds them to the specified group name. More...

void	renameParameterGroup (const std::string &old_name, const std::string &new_name)
	This method renames a parameter group. More...

std::string	getGroupName (const std::string &param_name) const
	This method retrieves the group name for the passed parameter name if one exists. More...

template<typename T >
void	suppressParameter (const std::string &name)
	This method suppresses an inherited parameter so that it isn't required or valid in the derived class. More...

template<typename T >
void	makeParamRequired (const std::string &name)
	Changes the parameter to be required. More...

template<typename T >
void	makeParamNotRequired (const std::string &name)
	Changes the parameter to not be required. More...

void	addCoupledVar (const std::string &name, const std::string &doc_string)
	This method adds a coupled variable name pair. More...

void	addDeprecatedCoupledVar (const std::string &old_name, const std::string &new_name, const std::string &removal_date="")
	This method adds a deprecated coupled variable name pair. More...

void	addCoupledVar (const std::string &name, const Real value, const std::string &doc_string)
	This method adds a coupled variable name pair. More...

void	addCoupledVar (const std::string &name, const std::vector< Real > &value, const std::string &doc_string)
	This method adds a coupled variable name pair. More...

std::string	getMooseType (const std::string &name) const
	Utility functions for retrieving one of the MooseTypes variables into the common "string" base class. More...

std::vector< std::string >	getVecMooseType (const std::string &name) const

void	addRequiredCoupledVar (const std::string &name, const std::string &doc_string)
	This method adds a coupled variable name pair. More...

std::string	getDocString (const std::string &name) const
	Returns the documentation string for the specified parameter name. More...

void	setDocString (const std::string &name, const std::string &doc)
	Set the doc string of a parameter. More...

std::string	getDocUnit (const std::string &name) const
	Returns the documentation unit string for the specified parameter name. More...

void	setDocUnit (const std::string &name, const std::string &doc_unit)
	Set the unit string of a parameter. More...

bool	isParamRequired (const std::string &name) const
	Returns a boolean indicating whether the specified parameter is required or not. More...

void	makeParamNotRequired (const std::string &name)
	Forces parameter of given name to be not required regardless of type. More...

bool	isParamValid (const std::string &name) const
	This method returns parameters that have been initialized in one fashion or another, i.e. More...

bool	isParamSetByAddParam (const std::string &name) const
	Returns whether or not the parameter was set due to addParam. More...

bool	isParamDeprecated (const std::string &name) const
	Returns True if the parameters is deprecated. More...

bool	areAllRequiredParamsValid () const
	This method returns true if all of the parameters in this object are valid (i.e. More...

std::string	type (const std::string &name) const
	Prints the type of the requested parameter by name. More...

bool	isPrivate (const std::string &name) const
	Returns a Boolean indicating whether the specified parameter is private or not. More...

void	declareControllable (const std::string &name, std::set< ExecFlagType > execute_flags={})
	Declare the given parameters as controllable. More...

void	markControlled (const std::string &name)
	Marker a parameter that has been changed by the Control system (this is for output purposes) More...

bool	isControllable (const std::string &name) const
	Returns a Boolean indicating whether the specified parameter is controllable. More...

const std::set< ExecFlagType > &	getControllableExecuteOnTypes (const std::string &name) const
	Return the allowed execute flags for a controllable parameter. More...

void	registerBase (const std::string &value)
	This method must be called from every base "Moose System" to create linkage with the Action System. More...

std::optional< std::string >	getBase () const

void	registerSystemAttributeName (const std::string &value)
	This method is used to define the MOOSE system name that is used by the TheWarehouse object for storing objects to be retrieved for execution. More...

const std::string &	getSystemAttributeName () const
	Get the system attribute name if it was registered. More...

void	registerBuildableTypes (const std::string &names)
	This method is here to indicate which Moose types a particular Action may build. More...

void	addRelationshipManager (const std::string &name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback input_parameter_callback=nullptr)
	Tells MOOSE about a RelationshipManager that this object needs. More...

void	clearRelationshipManagers ()
	Clears all currently registered RelationshipManagers. More...

const std::vector< std::string > &	getBuildableTypes () const
	Returns the list of buildable types as a std::vector<std::string> More...

const std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > &	getBuildableRelationshipManagerTypes () const
	Returns the list of buildable (or required) RelationshipManager object types for this object. More...

void	checkParams (const std::string &parsing_syntax)
	This function checks parameters stored in the object to make sure they are in the correct state as the user expects: Required parameters are verified as valid meaning that they were either initialized when they were created, or were read from an input file or some other valid source. More...

void	finalize (const std::string &parsing_syntax)
	Finalizes the parameters, which must be done before constructing any objects with these parameters (to be called in the corresponding factories). More...

std::filesystem::path	getFileBase (const std::optional< std::string > &param_name=std::optional< std::string >()) const

std::set< std::string >::const_iterator	coupledVarsBegin () const
	Methods returning iterators to the coupled variables names stored in this InputParameters object. More...

std::set< std::string >::const_iterator	coupledVarsEnd () const

const std::set< std::string > &	getCoupledVariableParamNames () const
	Return the coupled variable parameter names. More...

const std::unordered_map< std::string, std::string > &	getNewToDeprecatedVarMap () const
	Return the new to deprecated variable name map. More...

bool	isRangeChecked (const std::string &param_name) const
	Return whether a parameter has a range check. More...

std::string	rangeCheckedFunction (const std::string &name) const
	Return the range check function for any parameter (empty string if it is not range checked) More...

bool	hasDefault (const std::string &param_name) const
	Return whether a parameter has a default. More...

bool	hasCoupledValue (const std::string &coupling_name) const
	Return whether or not the coupled variable exists. More...

bool	hasDefaultCoupledValue (const std::string &coupling_name) const
	Return whether or not the requested parameter has a default coupled value. More...

Real	defaultCoupledValue (const std::string &coupling_name, unsigned int i=0) const
	Get the default value for an optionally coupled variable. More...

unsigned int	numberDefaultCoupledValues (const std::string &coupling_name) const
	Get the number of defaulted coupled value entries. More...

void	defaultCoupledValue (const std::string &coupling_name, Real value, unsigned int i=0)
	Set the default value for an optionally coupled variable (called by the Parser). More...

std::map< std::string, std::pair< std::string, std::string > >	getAutoBuildVectors () const
	Returns the auto build vectors for all parameters. More...

void	applyParameters (const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
	Method for applying common parameters. More...

void	applySpecificParameters (const InputParameters &common, const std::vector< std::string > &include, bool allow_private=false)
	Method for applying common parameters. More...

void	applyParameter (const InputParameters &common, const std::string &common_name, bool allow_private=false, bool override_default=false)
	Apply values from a single parameter in common, to a single parameter stored in this object. More...

void	applyCoupledVar (const InputParameters &common, const std::string &var_name)
	Apply properties of a single coupled variable in common, to a single coupled variable stored in this object. More...

bool	paramSetByUser (const std::string &name) const
	Deprecated method. More...

bool	isParamSetByUser (const std::string &name) const
	Method returns true if the parameter was set by the user. More...

bool	isParamDefined (const std::string &name) const
	Method returns true if the parameter is defined for any type. More...

template<typename R1 , typename R2 , typename V1 = typename std::conditional<std::is_same<R1, MooseEnumItem>::value, MultiMooseEnum, std::vector<R1>>::type, typename V2 = typename std::conditional<std::is_same<R2, MooseEnumItem>::value, MultiMooseEnum, std::vector<R2>>::type>
std::vector< std::pair< R1, R2 > >	get (const std::string &param1, const std::string &param2) const
	Combine two vector parameters into a single vector of pairs. More...

std::set< std::string >	getParametersList () const

std::set< std::string >	getControllableParameters () const
	Return list of controllable parameters. More...

std::set< std::string >	getGroupParameters (const std::string &group) const
	Return names of parameters within a group. More...

void	setReservedValues (const std::string &name, const std::set< std::string > &reserved)
	Provide a set of reserved values for a parameter. More...

std::set< std::string >	reservedValues (const std::string &name) const
	Get a set of reserved parameter values. More...

std::string	blockLocation () const

std::string	blockFullpath () const

const hit::Node *	getHitNode (const std::string &param) const

void	setHitNode (const std::string &param, const hit::Node &node, const SetParamHitNodeKey)
	Sets the hit node associated with the parameter `param` to `node`. More...

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

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

std::string	errorPrefix (const std::string &param) const
	generate error message prefix with parameter name and location (if available) More...

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

template<typename T >
void	ignoreParameter (const std::string &name)
	Informs this object that values for this parameter set from the input file or from the command line should be ignored. More...

bool	shouldIgnore (const std::string &name)
	Whether to ignore the value of an input parameter set in the input file or from the command line. More...

template<typename T >
bool	isType (const std::string &name) const

std::string	varName (const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
	Determine the actual variable name from the given variable parameter name. More...

void	renameParam (const std::string &old_name, const std::string &new_name, const std::string &new_docstring)
	Rename a parameter and provide a new documentation string. More...

void	renameCoupledVar (const std::string &old_name, const std::string &new_name, const std::string &new_docstring)
	Rename a coupled variable and provide a new documentation string. More...

void	deprecateParam (const std::string &old_name, const std::string &new_name, const std::string &removal_date)

void	deprecateCoupledVar (const std::string &old_name, const std::string &new_name, const std::string &removal_date)

std::string	checkForRename (const std::string &name) const
	Checks whether the provided name is a renamed parameter name. More...

template<typename T >
const T &	get (std::string_view name) const
	A wrapper around the `Parameters` base class method. More...

template<typename T >
bool	have_parameter (std::string_view name) const
	A wrapper around the `Parameters` base class method. More...

template<typename T >
void	transferParam (const InputParameters &source_param, const std::string &name, const std::string &new_name="", const std::string &new_description="")
	A routine to transfer a parameter from one class' validParams to another. More...

std::vector< std::string >	paramAliases (const std::string &param_name) const
	Return all the aliased names associated with `param_name`. More...

const hit::Node *	getHitNode () const

void	setHitNode (const hit::Node &node, const SetHitNodeKey)
	Sets the hit node that represents the syntax responsible for creating these parameters. More...

bool	isFinalized () const

std::optional< Moose::DataFileUtils::Path >	queryDataFileNamePath (const std::string &name) const

template<>
void	addRequiredParam (const std::string &name, const MooseEnum &moose_enum, const std::string &doc_string)

template<>
void	addRequiredParam (const std::string &name, const MultiMooseEnum &moose_enum, const std::string &doc_string)

template<>
void	addParam (const std::string &, const std::string &)

template<>
void	addParam (const std::string &, const std::string &)

template<>
void	addPrivateParam (const std::string &)

template<>
void	addPrivateParam (const std::string &)

template<>
void	addDeprecatedParam (const std::string &, const std::string &, const std::string &)

template<>
void	addDeprecatedParam (const std::string &, const std::string &, const std::string &)

template<>
const MooseEnum &	getParamHelper (const std::string &name, const InputParameters &pars, const MooseEnum , const MooseBase moose_base)

template<>
const MultiMooseEnum &	getParamHelper (const std::string &name, const InputParameters &pars, const MultiMooseEnum , const MooseBase moose_base)

template<>
void	addRequiredParam (const std::string &name, const MooseEnum &moose_enum, const std::string &doc_string)

template<>
void	addRequiredParam (const std::string &name, const MultiMooseEnum &moose_enum, const std::string &doc_string)

template<>
void	addParam (const std::string &, const std::string &)

template<>
void	addParam (const std::string &, const std::string &)

template<>
void	addPrivateParam (const std::string &)

template<>
void	addPrivateParam (const std::string &)

template<>
void	addDeprecatedParam (const std::string &, const std::string &, const std::string &)

template<>
void	addDeprecatedParam (const std::string &, const std::string &, const std::string &)

template<>
const MooseEnum &	getParamHelper (const std::string &name_in, const InputParameters &pars, const MooseEnum , const MooseBase )

template<>
const MultiMooseEnum &	getParamHelper (const std::string &name_in, const InputParameters &pars, const MultiMooseEnum , const MooseBase )

virtual Parameters &	operator+= (const Parameters &source)

void	insert (const std::string &)

T &	set (const std::string &)

void	remove (std::string_view)

std::size_t	n_parameters () const

unsigned int	n_parameters () const

void	print (std::ostream &os=libMesh::out) const

iterator	begin ()

const_iterator	begin () const

iterator	end ()

const_iterator	end () const


template<typename T , typename S >
void	addParam (const std::string &name, const S &value, const std::string &doc_string)
	These methods add an optional parameter and a documentation string to the InputParameters object. More...

template<typename T >
void	addParam (const std::string &name, const std::string &doc_string)


template<typename T >
void	addRequiredRangeCheckedParam (const std::string &name, const std::string &parsed_function, const std::string &doc_string)
	These methods add an range checked parameters. More...

template<typename T >
void	addRangeCheckedParam (const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)

template<typename T >
void	addRangeCheckedParam (const std::string &name, const std::string &parsed_function, const std::string &doc_string)


void	addCoupledVarWithAutoBuild (const std::string &name, const std::string &base_name, const std::string &num_name, const std::string &doc_string)
	These methods add a coupled variable name pair. More...

void	addRequiredCoupledVarWithAutoBuild (const std::string &name, const std::string &base_name, const std::string &num_name, const std::string &doc_string)


void	collapseSyntaxNesting (bool collapse)
	Mutators for controlling whether or not the outermost level of syntax will be collapsed when printed. More...

bool	collapseSyntaxNesting () const


void	mooseObjectSyntaxVisibility (bool visibility)
	Mutators for controlling whether or not the outermost level of syntax will be collapsed when printed. More...

bool	mooseObjectSyntaxVisibility () const


InputParameters &	operator= (const InputParameters &rhs)

InputParameters &	operator+= (const InputParameters &rhs)

Static Public Member Functions

template<typename T >
static const T &	getParamHelper (const std::string &name, const InputParameters &pars, const T the_type, const MooseBase moose_base=nullptr)

Protected Attributes
map_type	_values

Private Member Functions
	InputParameters ()

void	setParameters ()
	Method to terminate the recursive setParameters definition. More...

template<typename T >
std::string	appendFunctorDescription (const std::string &doc_string) const
	Appends description of what a functor is to a doc string. More...

void	setDeprecatedVarDocString (const std::string &new_name, const std::string &doc_string)
	Private method for setting deprecated coupled variable documentation strings. More...

void	renameParamInternal (const std::string &old_name, const std::string &new_name, const std::string &docstring, const std::string &removal_date)

void	renameCoupledVarInternal (const std::string &old_name, const std::string &new_name, const std::string &docstring, const std::string &removal_date)

Metadata &	at (const std::string &param_name)

const Metadata &	at (const std::string &param_name) const

void	allowCopy (bool status)
	Toggle the availability of the copy constructor. More...

void	checkParamName (const std::string &name) const
	Make sure the parameter name doesn't have any invalid characters. More...

template<typename T , typename S >
void	setParamHelper (const std::string &name, T &l_value, const S &r_value)
	This method is called when adding a Parameter with a default value, can be specialized for non-matching types. More...

template<typename T >
void	addCommandLineParamHelper (const std::string &name, const std::string &syntax, const bool required, const bool value_required)
	Helper for all of the addCommandLineParam() calls, which sets up _cl_data in the metadata. More...

template<>
void	setParamHelper (const std::string &name, PostprocessorName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &name, PostprocessorName &l_value, const int &r_value)

template<>
void	setParamHelper (const std::string &, FunctionName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &, FunctionName &l_value, const int &r_value)

template<>
void	setParamHelper (const std::string &, MaterialPropertyName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &, MaterialPropertyName &l_value, const int &r_value)

template<>
void	setParamHelper (const std::string &, MooseFunctorName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &, MooseFunctorName &l_value, const int &r_value)

template<>
void	setParamHelper (const std::string &, PostprocessorName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &, PostprocessorName &l_value, const int &r_value)

template<>
void	setParamHelper (const std::string &, FunctionName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &, FunctionName &l_value, const int &r_value)

template<>
void	setParamHelper (const std::string &, MaterialPropertyName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &, MaterialPropertyName &l_value, const int &r_value)

template<>
void	setParamHelper (const std::string &, MooseFunctorName &l_value, const Real &r_value)

template<>
void	setParamHelper (const std::string &, MooseFunctorName &l_value, const int &r_value)

Static Private Member Functions
template<typename T >
static constexpr bool	isFunctorNameType ()

static void	callMooseErrorHelper (const MooseBase &moose_base, const std::string &error)

Private Attributes
std::string	_block_location
	original location of input block (i.e. filename,linenum) - used for nice error messages. More...

std::string	_block_fullpath
	full HIT path of the block from the input file - used for nice error messages. More...

std::map< std::string, Metadata >	_params
	The actual parameter data. More...

std::set< std::string >	_coupled_vars
	The coupled variables set. More...

std::string	_class_description
	The class description for the owning object. More...

std::vector< std::string >	_buildable_types
	The parameter is used to restrict types that can be built. More...

std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > >	_buildable_rm_types
	The RelationshipManagers that this object may either build or require. More...

bool	_collapse_nesting
	This parameter collapses one level of nesting in the syntax blocks. More...

bool	_moose_object_syntax_visibility
	This parameter hides derived MOOSE object types from appearing in syntax dumps. More...

bool	_show_deprecated_message
	Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping messages. More...

bool	_allow_copy
	A flag for toggling the error message in the copy constructor. More...

std::unordered_map< std::string, std::string >	_new_to_deprecated_coupled_vars
	A map from deprecated coupled variable names to the new blessed name. More...

std::map< std::string, std::pair< std::string, std::string > >	_old_to_new_name_and_dep
	A map from base-class/deprecated parameter names to derived-class/blessed parameter names and the deprecation messages in the case that the "old" parameter name is a deprecated parameter name. More...

std::multimap< std::string, std::string >	_new_to_old_names
	A map from derived-class/blessed parameter names to associated base-class/deprecated parameter names. More...

const hit::Node *	_hit_node
	The hit node representing the syntax that created these parameters, if any. More...

bool	_finalized
	Whether or not we've called finalize() on these parameters yet. More...

Friends
class	InputParameterWarehouse

class	Parser

class	ActionWarehouse

InputParameters	emptyInputParameters ()

Detailed Description

The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system.

Definition at line 66 of file InputParameters.h.

Constructor & Destructor Documentation

◆ InputParameters() [1/3]

InputParameters::InputParameters ( const InputParameters & rhs )

Definition at line 47 of file InputParameters.C.

   : Parameters(), _show_deprecated_message(true), _allow_copy(true)
 {
   *this = rhs;
 }

◆ InputParameters() [2/3]

InputParameters::InputParameters ( const Parameters & rhs )

Definition at line 53 of file InputParameters.C.

   : _show_deprecated_message(true), _allow_copy(true)
 {
   _params.clear();
   Parameters::operator=(rhs);
   _collapse_nesting = false;
   _moose_object_syntax_visibility = true;
 }

◆ ~InputParameters()

virtual InputParameters::~InputParameters ( )

virtualdefault

◆ InputParameters() [3/3]

InputParameters::InputParameters ( )

private

Definition at line 36 of file InputParameters.C.

   : Parameters(),
     _collapse_nesting(false),
     _moose_object_syntax_visibility(true),
     _show_deprecated_message(true),
     _allow_copy(true),
     _hit_node(nullptr),
     _finalized(false)
 {
 }

Member Function Documentation

◆ addClassDescription()

void InputParameters::addClassDescription ( const std::string & doc_string )

This method adds a description of the class that will be displayed in the input file syntax dump.

Definition at line 82 of file InputParameters.C.

 {
   _class_description = doc_string;
 }

◆ addCommandLineParam() [1/3]

template<typename T >

void InputParameters::addCommandLineParam	(	const std::string &	name,
		const std::string &	syntax,
		const std::string &	doc_string
	)

Definition at line 1873 of file InputParameters.h.

Referenced by MooseApp::addAppParam(), MooseApp::addInputParam(), and MooseApp::validParams().

 {
   static_assert(!std::is_same_v<T, MooseEnum>,
                 "addCommandLineParam() without a value cannot be used with a MooseEnum because a "
                 "MooseEnum requires initialization");
 
   auto constexpr is_bool = std::is_same_v<T, bool>;
   if constexpr (is_bool)
     addParam<T>(name, false, doc_string);
   else
     addParam<T>(name, doc_string);
 
   addCommandLineParamHelper<T>(
       name, syntax, /* required = */ false, /* value_required = */ !is_bool);
 }

◆ addCommandLineParam() [2/3]

template<typename T >

void InputParameters::addCommandLineParam	(	const std::string &	name,
		const std::string &	syntax,
		const T &	value,
		const std::string &	doc_string
	)

Definition at line 1893 of file InputParameters.h.

 {
   if constexpr (std::is_same_v<T, bool>)
     mooseAssert(!value, "Default for bool must be false");
 
   addParam<T>(name, value, doc_string);
   addCommandLineParamHelper<T>(name, syntax, /* required = */ false, /* value_required = */ true);
 }

◆ addCommandLineParam() [3/3]

template<typename T >

void InputParameters::addCommandLineParam	(	const std::string &	name,
		const std::string &	syntax,
		const std::initializer_list< typename T::value_type > &	value,
		const std::string &	doc_string
	)

inline

Definition at line 343 of file InputParameters.h.

   {
     addCommandLineParam<T>(name, syntax, T{value}, doc_string);
   }

◆ addCommandLineParamHelper()

template<typename T >

void InputParameters::addCommandLineParamHelper	(	const std::string &	name,
		const std::string &	syntax,
		const bool	required,
		const bool	value_required
	)

private

Helper for all of the addCommandLineParam() calls, which sets up _cl_data in the metadata.

Parameters

name	The parameter name
syntax	The parameter syntax
required	Whether or not the parameter is required
value_required	Whethre or not the parameter requires a value

Definition at line 1698 of file InputParameters.h.

 {
   static_assert(isValidCommandLineType<T>::value,
                 "This type is not a supported command line parameter type. See "
                 "CommandLine::populateCommandLineParams to add it as a supported type.");
 
   auto & cl_data = at(name)._cl_data;
   cl_data = CommandLineMetadata();
 
   // Split up the syntax by whitespace
   std::vector<std::string> syntax_split;
   MooseUtils::tokenize(syntax, syntax_split, 1, " \t\n\v\f\r");
 
   // Set the single syntax string as the combined syntax with removed whitespace
   cl_data->syntax = MooseUtils::stringJoin(syntax_split);
   mooseAssert(cl_data->syntax.size(), "Empty token");
 
   // Set the switches; only parse those that begin with "-" as we also
   // provide examples within the syntax
   for (const auto & val : syntax_split)
     if (val.rfind("-", 0) == 0)
     {
       if (!std::regex_search(val, std::regex("^\\-+[a-zA-Z]")))
         mooseError("The switch '",
                    val,
                    "' for the command line parameter '",
                    name,
                    "' is invalid. It must begin with an alphabetical character.");
 
       cl_data->switches.push_back(val);
       libMesh::add_command_line_name(val);
     }
 
   cl_data->required = required;
   cl_data->global = false;
 
   // No arguments needed for a boolean parameter
   if constexpr (std::is_same_v<T, bool>)
   {
     (void)value_required; // purposely unused; doesn't take a value
     cl_data->argument_type = CommandLineMetadata::ArgumentType::NONE;
   }
   // MooseEnums require a value
   else if constexpr (std::is_same_v<T, MooseEnum>)
   {
     (void)value_required; // purposely unused; always required
     cl_data->argument_type = CommandLineMetadata::ArgumentType::REQUIRED;
   }
   // The user didn't specify a default, so a value is required
   else if (value_required)
     cl_data->argument_type = CommandLineMetadata::ArgumentType::REQUIRED;
   // Otherwise, it's optional (user specified a default)
   else
     cl_data->argument_type = CommandLineMetadata::ArgumentType::OPTIONAL;
 }

◆ addCoupledVar() [1/3]

void InputParameters::addCoupledVar	(	const std::string &	name,
		const std::string &	doc_string
	)

This method adds a coupled variable name pair.

The parser will look for variable name pair in the input file and can return a reference to the storage location for the coupled variable if found

Definition at line 257 of file InputParameters.C.

Referenced by applyCoupledVar(), transferParam(), BuildArrayVariableAux::validParams(), ArrayHFEMDirichletBC::validParams(), HFEMDirichletBC::validParams(), DerivativeSumMaterialTempl< is_ad >::validParams(), PenetrationAux::validParams(), ElementExtremeValue::validParams(), SideExtremeValue::validParams(), NodalExtremeValue::validParams(), InterfaceQpValueUserObject::validParams(), FunctionDiffusion::validParams(), ParsedODEKernel::validParams(), ParsedMaterialBase::validParams(), VectorFromComponentVariablesMaterialTempl< is_ad >::validParams(), VectorMagnitudeAux::validParams(), ArrayParsedAux::validParams(), SpatialAverageBase::validParams(), ParsedAux::validParams(), ParsedVectorAux::validParams(), NodalNormalBC::validParams(), VariableValueVolumeHistogram::validParams(), ADMatReaction::validParams(), QuotientScalarAux::validParams(), PointwiseRenormalizeVector::validParams(), QuotientAux::validParams(), CoupledValueFunctionMaterialTempl< is_ad >::validParams(), ElementVectorL2Error::validParams(), ADKernelSUPGTempl< T >::validParams(), FindValueOnLine::validParams(), MatReaction::validParams(), ADMortarScalarBase::validParams(), MortarScalarBase::validParams(), CoupledVarNeumannBCTempl< false >::validParams(), KernelScalarBase::validParams(), ADKernelScalarBase::validParams(), ADMatDiffusionBase< Real >::validParams(), InterfaceIntegralVariableValuePostprocessor::validParams(), SideAdvectiveFluxIntegralTempl< is_ad >::validParams(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::validParams(), BoundaryCondition::validParams(), NodeFaceConstraint::validParams(), ConservativeAdvectionTempl< is_ad >::validParams(), MortarConstraintBase::validParams(), MatDiffusionBase< Real >::validParams(), FVInterfaceKernel::validParams(), and FVBoundaryCondition::validParams().

 {
   addParam<std::vector<VariableName>>(name, doc_string);
   _coupled_vars.insert(name);
 
   // Set the doc string for any associated deprecated coupled var
   setDeprecatedVarDocString(name, doc_string);
 }

◆ addCoupledVar() [2/3]

void InputParameters::addCoupledVar	(	const std::string &	name,
		const Real	value,
		const std::string &	doc_string
	)

This method adds a coupled variable name pair.

The parser will look for variable name pair in the input file and can return a reference to the storage location for the coupled variable if found

Also - you can provide a default value for this variable in the case that an actual variable is not provided.

Definition at line 228 of file InputParameters.C.

 {
   addParam<std::vector<VariableName>>(name, doc_string);
   _coupled_vars.insert(name);
   auto & metadata = _params[name];
   metadata._coupled_default.assign(1, value);
   metadata._have_coupled_default = true;
 
   // Set the doc string for any associated deprecated coupled var
   setDeprecatedVarDocString(name, doc_string);
 }

◆ addCoupledVar() [3/3]

void InputParameters::addCoupledVar	(	const std::string &	name,
		const std::vector< Real > &	value,
		const std::string &	doc_string
	)

This method adds a coupled variable name pair.

The parser will look for variable name pair in the input file and can return a reference to the storage location for the coupled variable if found

Also - you can provide a vector of values for this variable in the case that an actual variable is not provided.

Definition at line 241 of file InputParameters.C.

 {
   // std::vector<VariableName>(1, Moose::stringify(value)),
   addParam<std::vector<VariableName>>(name, doc_string);
   _coupled_vars.insert(name);
   auto & metadata = _params[name];
   metadata._coupled_default = value;
   metadata._have_coupled_default = true;
 
   // Set the doc string for any associated deprecated coupled var
   setDeprecatedVarDocString(name, doc_string);
 }

◆ addCoupledVarWithAutoBuild()

void InputParameters::addCoupledVarWithAutoBuild	(	const std::string &	name,
		const std::string &	base_name,
		const std::string &	num_name,
		const std::string &	doc_string
	)

These methods add a coupled variable name pair.

The parser will look for variable name pair in the input file and can return a reference to the storage location for the coupled variable if found.

This version of the method will build a vector if the given the base_name and num_name parameters exist in the input file: e.g. [./foo] ... some_base = base_ some_num = 5 [../]

The coupling parameter will be passed this vector: "base_0 base_1 base_2 base_3 base_4"

Definition at line 295 of file InputParameters.C.

Referenced by addRequiredCoupledVarWithAutoBuild().

 {
   addParam<std::vector<VariableName>>(name, doc_string);
   _coupled_vars.insert(name);
   _params[name]._autobuild_vecs = std::make_pair(base_name, num_name);
 
   // Additionally there are two more parameters that need to be added:
   addParam<std::string>(base_name, doc_string + " (base_name)");
   addParam<unsigned int>(num_name, doc_string + " (num_name)");
 }

◆ addCustomTypeParam() [1/2]

template<typename T >

void InputParameters::addCustomTypeParam	(	const std::string &	name,
		const T &	value,
		const std::string &	custom_type,
		const std::string &	doc_string
	)

Definition at line 1800 of file InputParameters.h.

Referenced by ParsedVectorAux::validParams(), ParsedMaterialBase::validParams(), ParsedConvergence::validParams(), SolutionUserObject::validParams(), and MooseParsedFunction::validParams().

 {
   addParam<T>(name, value, doc_string);
   _params[name]._custom_type = custom_type;
 }

◆ addCustomTypeParam() [2/2]

template<typename T >

void InputParameters::addCustomTypeParam	(	const std::string &	name,
		const std::string &	custom_type,
		const std::string &	doc_string
	)

Definition at line 1811 of file InputParameters.h.

 {
   addParam<T>(name, doc_string);
   _params[name]._custom_type = custom_type;
 }

◆ addDeprecatedCoupledVar()

void InputParameters::addDeprecatedCoupledVar	(	const std::string &	old_name,
		const std::string &	new_name,
		const std::string &	removal_date = `""`
	)

This method adds a deprecated coupled variable name pair.

The parser will look for variable name pair in the input file and can return a reference to the storage location for the coupled variable if found. The doc string for the deprecated variable will be constructed from the doc string for the new variable. A deprecation message will also be automatically generated

Definition at line 267 of file InputParameters.C.

 {
   mooseDeprecated("Please use 'deprecateCoupledVar'");
 
   _show_deprecated_message = false;
 
   // Set the doc string if we are adding the deprecated var after the new var has already been added
   auto params_it = _params.find(new_name);
   std::string doc_string;
   if (params_it != _params.end())
     doc_string = params_it->second._doc_string;
 
   addParam<std::vector<VariableName>>(old_name, doc_string);
   _coupled_vars.insert(old_name);
   _new_to_deprecated_coupled_vars.emplace(new_name, old_name);
 
   std::string deprecation_message =
       "The coupled variable parameter '" + old_name + "' has been deprecated";
   if (!removal_date.empty())
     deprecation_message += " and will be removed " + removal_date;
   deprecation_message += ". Please use the '" + new_name + "' coupled variable parameter instead.";
   _params[old_name]._deprecation_message = deprecation_message;
   _show_deprecated_message = true;
 }

◆ addDeprecatedCustomTypeParam()

template<typename T >

void InputParameters::addDeprecatedCustomTypeParam	(	const std::string &	name,
		const std::string &	custom_type,
		const std::string &	doc_string,
		const std::string &	deprecation_msg
	)

Definition at line 1821 of file InputParameters.h.

Referenced by ParsedMaterialBase::validParams(), and MooseParsedFunction::validParams().

 {
   _show_deprecated_message = false;
   addParam<T>(name, doc_string);
   auto & metadata = _params[name];
   metadata._custom_type = custom_type;
 
   metadata._deprecation_message = deprecation_message;
   _show_deprecated_message = true;
 }

◆ addDeprecatedParam() [1/6]

template<typename T >

void InputParameters::addDeprecatedParam	(	const std::string &	name,
		const T &	value,
		const std::string &	doc_string,
		const std::string &	deprecation_message
	)

Parameters

name	The name of the parameter
value	The default value of this parameter if it requires one
doc_string	Documentation. This will be shown for –help
deprecation_message	The message that will will print about why this param was deprecated. It might mention the "new way".

Definition at line 1991 of file InputParameters.h.

Referenced by AdaptivityAction::validParams(), SetupDebugAction::validParams(), BlockDeletionGenerator::validParams(), RenameBlockGenerator::validParams(), AnnularMesh::validParams(), ParsedSubdomainGeneratorBase::validParams(), Console::validParams(), PostprocessorDT::validParams(), AnnularMeshGenerator::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), ElementSubdomainModifierBase::validParams(), VectorFunctionDirichletBC::validParams(), FixedPointSolve::validParams(), DerivativeKernelInterface< T >::validParams(), MooseParsedVectorFunction::validParams(), Exodus::validParams(), CommonOutputAction::validParams(), PropertyReadFile::validParams(), MooseParsedGradFunction::validParams(), MultiAppUserObjectTransfer::validParams(), MultiAppTransfer::validParams(), FunctionMaterialBase< is_ad >::validParams(), SampledOutput::validParams(), MooseParsedFunctionBase::validParams(), DerivativeFunctionMaterialBaseTempl< is_ad >::validParams(), MatDiffusionBase< Real >::validParams(), Executioner::validParams(), Output::validParams(), MultiApp::validParams(), and FEProblemBase::validParams().

 {
   _show_deprecated_message = false;
   mooseAssert(!_old_to_new_name_and_dep.count(name),
               "Attempting to deprecate via addDeprecatedParam the parameter, '"
                   << name << "', already deprecated via deprecateParam or renamed via renameParam");
   addParam<T>(name, value, doc_string);
 
   _params[name]._deprecation_message = deprecation_message;
   _show_deprecated_message = true;
 }

◆ addDeprecatedParam() [2/6]

template<typename T >

void InputParameters::addDeprecatedParam	(	const std::string &	name,
		const std::string &	doc_string,
		const std::string &	deprecation_message
	)

Definition at line 2008 of file InputParameters.h.

 {
   _show_deprecated_message = false;
   mooseAssert(!_old_to_new_name_and_dep.count(name),
               "Attempting to deprecate via addDeprecatedParam the parameter, '"
                   << name << "', already deprecated via deprecateParam or renamed via renameParam");
   addParam<T>(name, doc_string);
 
   _params[name]._deprecation_message = deprecation_message;
   _show_deprecated_message = true;
 }

◆ addDeprecatedParam() [3/6]

template<>

void InputParameters::addDeprecatedParam	(	const std::string &	,
		const std::string &	,
		const std::string &
	)

Definition at line 1334 of file InputParameters.C.

 {
   mooseError("You must supply a MooseEnum object and the deprecation string when using "
              "addDeprecatedParam, even if the parameter is not required!");
 }

◆ addDeprecatedParam() [4/6]

template<>

void InputParameters::addDeprecatedParam	(	const std::string &	,
		const std::string &	,
		const std::string &
	)

Definition at line 1344 of file InputParameters.C.

 {
   mooseError("You must supply a MultiMooseEnum object and the deprecation string when using "
              "addDeprecatedParam, even if the parameter is not required!");
 }

◆ addDeprecatedParam() [5/6]

template<>

void InputParameters::addDeprecatedParam	(	const std::string &	,
		const std::string &	,
		const std::string &
	)

◆ addDeprecatedParam() [6/6]

template<>

void InputParameters::addDeprecatedParam	(	const std::string &	,
		const std::string &	,
		const std::string &
	)

◆ addOptionalValuedCommandLineParam()

template<typename T >

void InputParameters::addOptionalValuedCommandLineParam	(	const std::string &	name,
		const std::string &	syntax,
		const T &	value,
		const std::string &	doc_string
	)

Add a command line parameter with an optional value.

This is a deprecated option and only remains for two parameters: "mesh_only" and "recover". There are issues with command line parameters with optional values because if a value following one of these is a hit cli parameter, we don't know if we should apply it to the optional option or as a hit parameter.

It is also allowed for "run" as we take all arguments past –run and pass to python.

Parameters

name	The name of the parameer
syntax	Space separated list of command-line switch syntax that can set this option
value	The default value to assign
doc_string	Documentation. This will be shown for –help

Definition at line 1907 of file InputParameters.h.

Referenced by MooseApp::validParams().

 {
   mooseAssert(name == "mesh_only" || name == "recover" || name == "run",
               "Not supported for new parameters");
   static_assert(!std::is_same_v<T, bool>, "Cannot be used for a bool (does not take a value)");
   addParam<T>(name, value, doc_string);
   addCommandLineParamHelper<T>(name, syntax, /* required = */ false, /* value_required = */ false);
 }

◆ addParam() [1/7]

template<typename T , typename S >

void InputParameters::addParam	(	const std::string &	name,
		const S &	value,
		const std::string &	doc_string
	)

These methods add an optional parameter and a documentation string to the InputParameters object.

The first version of this function takes a default value which is used if the parameter is not found in the input file. The second method will leave the parameter uninitialized but can be checked with "isParamValid" before use.

Definition at line 1654 of file InputParameters.h.

 {
   checkParamName(name);
   checkConsistentType<T>(name);
 
   T & l_value = InputParameters::set<T>(name);
   auto & metadata = _params[name];
   if constexpr (isFunctorNameType<T>())
     metadata._doc_string = appendFunctorDescription<T>(doc_string);
   else
     metadata._doc_string = doc_string;
 
   // Set the parameter now
   setParamHelper(name, l_value, value);
 
   /* Indicate the default value, as set via addParam, is being used. The parameter is removed from
      the list whenever
      it changes, see set_attributes */
   metadata._set_by_add_param = true;
 }

◆ addParam() [2/7]

template<typename T >

void InputParameters::addParam	(	const std::string &	name,
		const std::string &	doc_string
	)

Definition at line 1677 of file InputParameters.h.

 {
   checkParamName(name);
   checkConsistentType<T>(name);
 
   InputParameters::insert<T>(name);
   if constexpr (isFunctorNameType<T>())
     _params[name]._doc_string = appendFunctorDescription<T>(doc_string);
   else
     _params[name]._doc_string = doc_string;
 }

◆ addParam() [3/7]

template<typename T >

void InputParameters::addParam	(	const std::string &	name,
		const std::initializer_list< typename T::value_type > &	value,
		const std::string &	doc_string
	)

inline

Enable support for initializer lists as default arguments for container type.

Definition at line 257 of file InputParameters.h.

   {
     addParam<T>(name, T{value}, doc_string);
   }

◆ addParam() [4/7]

template<>

void InputParameters::addParam	(	const std::string &	,
		const std::string &
	)

Definition at line 1273 of file InputParameters.C.

 {
   mooseError("You must supply a MooseEnum object when using addParam, even if the parameter is not "
              "required!");
 }

◆ addParam() [5/7]

template<>

void InputParameters::addParam	(	const std::string &	,
		const std::string &
	)

Definition at line 1282 of file InputParameters.C.

 {
   mooseError("You must supply a MultiMooseEnum object when using addParam, even if the parameter "
              "is not required!");
 }

◆ addParam() [6/7]

template<>

void InputParameters::addParam	(	const std::string &	,
		const std::string &
	)

◆ addParam() [7/7]

template<>

void InputParameters::addParam	(	const std::string &	,
		const std::string &
	)

◆ addParamNamesToGroup()

void InputParameters::addParamNamesToGroup	(	const std::string &	space_delim_names,
		const std::string	group_name
	)

This method takes a space delimited list of parameter names and adds them to the specified group name.

This information is used in the GUI to group parameters into logical sections.

Definition at line 930 of file InputParameters.C.

 {
   std::vector<std::string> elements;
   MooseUtils::tokenize(space_delim_names, elements, 1, " \t\n\v\f\r"); // tokenize on whitespace
 
   // Since we don't require types (templates) for this method, we need
   // to get a raw list of parameter names to compare against.
   std::set<std::string> param_names;
   for (const auto & it : *this)
     param_names.insert(it.first);
 
   for (const auto & param_name : elements)
     if (_params.count(param_name) > 0)
       _params[param_name]._group = group_name;
     else
       mooseError("Unable to find a parameter with name: ",
                  param_name,
                  " when adding to group ",
                  group_name,
                  '.');
 }

◆ addPrivateParam() [1/6]

template<typename T >

void InputParameters::addPrivateParam	(	const std::string &	name,
		const T &	value
	)

These method add a parameter to the InputParameters object which can be retrieved like any other parameter.

This parameter however is not printed in the Input file syntax dump or web page dump so does not take a documentation string. The first version of this function takes an optional default value.

Definition at line 1848 of file InputParameters.h.

Referenced by AddControlAction::act(), FEProblemBase::addOutput(), ActionFactory::create(), ActionFactory::getValidParams(), AppFactory::storeAppParams(), GlobalParamsAction::validParams(), CreateProblemDefaultAction::validParams(), ElementReporter::validParams(), GeneralReporter::validParams(), NodalReporter::validParams(), DefaultConvergenceBase::validParams(), XDA::validParams(), InternalSideIndicatorBase::validParams(), DefaultNonlinearConvergence::validParams(), MFEMFunctorMaterial::validParams(), CopyMeshPartitioner::validParams(), MoosePartitioner::validParams(), MaterialOutputAction::validParams(), BoundaryRestrictableRequired::validParams(), RelationshipManager::validParams(), NodalNormalsPreprocessor::validParams(), EigenExecutionerBase::validParams(), MooseObject::validParams(), Action::validParams(), VectorPostprocessor::validParams(), MoosePreconditioner::validParams(), Eigenvalue::validParams(), DisplacedProblem::validParams(), MooseVariableBase::validParams(), BoundaryRestrictable::validParams(), MeshGenerator::validParams(), Executioner::validParams(), Output::validParams(), Checkpoint::validParams(), BlockRestrictable::validParams(), MaterialPropertyInterface::validParams(), AuxKernelTempl< Real >::validParams(), MaterialBase::validParams(), MultiApp::validParams(), MooseApp::validParams(), and FEProblemBase::validParams().

 {
   checkParamName(name);
   checkConsistentType<T>(name);
 
   InputParameters::set<T>(name) = value;
   auto & metadata = _params[name];
   metadata._is_private = true;
   metadata._set_by_add_param = true;
 }

◆ addPrivateParam() [2/6]

template<typename T >

void InputParameters::addPrivateParam ( const std::string & name )

Definition at line 1837 of file InputParameters.h.

 {
   checkParamName(name);
   checkConsistentType<T>(name);
 
   InputParameters::insert<T>(name);
   _params[name]._is_private = true;
 }

◆ addPrivateParam() [3/6]

template<>

void InputParameters::addPrivateParam ( const std::string & )

Definition at line 1318 of file InputParameters.C.

 {
   mooseError("You must supply a MooseEnum object when using addPrivateParam, even if the parameter "
              "is not required!");
 }

◆ addPrivateParam() [4/6]

template<>

void InputParameters::addPrivateParam ( const std::string & )

Definition at line 1326 of file InputParameters.C.

 {
   mooseError("You must supply a MultiMooseEnum object when using addPrivateParam, even if the "
              "parameter is not required!");
 }

◆ addPrivateParam() [5/6]

template<>

void InputParameters::addPrivateParam ( const std::string & )

◆ addPrivateParam() [6/6]

template<>

void InputParameters::addPrivateParam ( const std::string & )

◆ addRangeCheckedParam() [1/2]

template<typename T >

void InputParameters::addRangeCheckedParam	(	const std::string &	name,
		const T &	value,
		const std::string &	parsed_function,
		const std::string &	doc_string
	)

Definition at line 1769 of file InputParameters.h.

 {
   addParam<T>(name, value, doc_string);
   _params[name]._range_function = parsed_function;
 }

◆ addRangeCheckedParam() [2/2]

template<typename T >

void InputParameters::addRangeCheckedParam	(	const std::string &	name,
		const std::string &	parsed_function,
		const std::string &	doc_string
	)

Definition at line 1780 of file InputParameters.h.

 {
   addParam<T>(name, doc_string);
   _params[name]._range_function = parsed_function;
 }

◆ addRelationshipManager()

void InputParameters::addRelationshipManager	(	const std::string &	name,
		Moose::RelationshipManagerType	rm_type,
		Moose::RelationshipManagerInputParameterCallback	input_parameter_callback = `nullptr`
	)

Tells MOOSE about a RelationshipManager that this object needs.

RelationshipManagers handle element "ghosting", "non-local DOF access" and "sparsity pattern" relationships.

Basically: if this object needs non-local (ie non-current-element) data access then you probably need a relationship manager

Parameters

name	The name of the RelationshipManager type
rm_type	The type (GEOMETRIC/ALGEBRAIC) of the RelationshipManger. Note: You can use boolean logic to to "or" RelationshipManagerTypes together to make a RelationshipManager that is multi-typed.
input_parameter_callback	This is a function pointer that will get called to fill in the RelationShipManager's InputParameters. See MooseTypes.h for the signature of this function.

Definition at line 526 of file InputParameters.C.

Referenced by GradientJumpIndicator::validParams(), NodalPatchRecoveryBase::validParams(), ElemSideNeighborLayersGeomTester::validParams(), ElemSideNeighborLayersTester::validParams(), Tecplot::validParams(), GMVOutput::validParams(), ProjectedStatefulMaterialNodalPatchRecoveryBase::validParams(), FunctorElementalGradientAuxTempl< is_ad >::validParams(), FVAnisotropicDiffusion::validParams(), FVRelationshipManagerInterface::validParams(), FVFunctorDirichletBCTempl< is_ad >::validParams(), ProjectionAux::validParams(), MultiAppProjectionTransfer::validParams(), Exodus::validParams(), FVDiffusion::validParams(), DistributedRectilinearMeshGenerator::validParams(), InterfaceKernelBase::validParams(), InterfaceUserObjectBase::validParams(), InternalSideUserObject::validParams(), SideUserObject::validParams(), RadialAverage::validParams(), InterfaceMaterial::validParams(), ProjectedStatefulMaterialNodalPatchRecoveryTempl< T, is_ad >::validParams(), MortarConsumerInterface::validParams(), DGKernelBase::validParams(), MortarConstraintBase::validParams(), DomainUserObject::validParams(), FVInterfaceKernel::validParams(), AuxKernelTempl< Real >::validParams(), and MooseVariableFV< Real >::validParams().

 {
   _buildable_rm_types.emplace_back(name, rm_type, input_parameter_callback);
 }

◆ addRequiredCommandLineParam()

template<typename T >

void InputParameters::addRequiredCommandLineParam	(	const std::string &	name,
		const std::string &	syntax,
		const std::string &	doc_string
	)

Add parameters for retrieval from the command line.

NOTE: This ONLY works for App objects! This is not valid for normal MOOSE objects!

Parameters

name	The name of the parameter
syntax	Space separated list of command-line switch syntax that can set this option
doc_string	Documentation. This will be shown for –help

Definition at line 1861 of file InputParameters.h.

 {
   static_assert(!std::is_same_v<T, bool>, "Cannot be used for a bool");
 
   addRequiredParam<T>(name, doc_string);
   addCommandLineParamHelper<T>(name, syntax, /* required = */ true, /* value_required = */ true);
 }

◆ addRequiredCoupledVar()

void InputParameters::addRequiredCoupledVar	(	const std::string &	name,
		const std::string &	doc_string
	)

This method adds a coupled variable name pair.

The parser will look for variable name pair in the input file and can return a reference to the storage location for the coupled variable. If the coupled variable is not supplied in the input file, and error is thrown.

Version 2: An auto built vector will be built from the base_name and num_name param. See addCoupledVar for an example

Definition at line 321 of file InputParameters.C.

 {
   addRequiredParam<std::vector<VariableName>>(name, doc_string);
   _coupled_vars.insert(name);
 }

◆ addRequiredCoupledVarWithAutoBuild()

void InputParameters::addRequiredCoupledVarWithAutoBuild	(	const std::string &	name,
		const std::string &	base_name,
		const std::string &	num_name,
		const std::string &	doc_string
	)

Definition at line 310 of file InputParameters.C.

 {
   addRequiredParam<std::vector<VariableName>>(name, doc_string);
 
   addCoupledVarWithAutoBuild(name, base_name, num_name, doc_string);
 }

◆ addRequiredCustomTypeParam()

template<typename T >

void InputParameters::addRequiredCustomTypeParam	(	const std::string &	name,
		const std::string &	custom_type,
		const std::string &	doc_string
	)

These methods add an option parameter and with a customer type to the InputParameters object.

The custom type will be output in YAML dumps and can be used within the GUI application.

Definition at line 1790 of file InputParameters.h.

Referenced by ArrayParsedAux::validParams(), ParsedAux::validParams(), ParsedPostprocessor::validParams(), ParsedODEKernel::validParams(), ParsedVectorAux::validParams(), ParsedFunctorMaterialTempl< is_ad >::validParams(), ParsedConvergence::validParams(), ParsedChainControl::validParams(), ParsedDownSelectionPositions::validParams(), and Terminator::validParams().

 {
   addRequiredParam<T>(name, doc_string);
   _params[name]._custom_type = custom_type;
 }

◆ addRequiredParam() [1/6]

template<typename T >

void InputParameters::addRequiredParam	(	const std::string &	name,
		const std::string &	doc_string
	)

This method adds a parameter and documentation string to the InputParameters object that will be extracted from the input file.

If the parameter is missing in the input file, an error will be thrown

Definition at line 1628 of file InputParameters.h.

 {
   checkParamName(name);
   checkConsistentType<T>(name);
 
   InputParameters::insert<T>(name);
   auto & metadata = _params[name];
   metadata._required = true;
   if constexpr (isFunctorNameType<T>())
     metadata._doc_string = appendFunctorDescription<T>(doc_string);
   else
     metadata._doc_string = doc_string;
 }

◆ addRequiredParam() [2/6]

template<typename T >

void InputParameters::addRequiredParam	(	const std::string &	name,
		const T &	moose_enum,
		const std::string &	doc_string
	)

This version of addRequiredParam is here for a consistent use with MooseEnums.

Use of this function for any other type will throw an error.

Definition at line 1644 of file InputParameters.h.

 {
   mooseError("You cannot call addRequiredParam and supply a default value for this type, please "
              "use addParam instead");
 }

◆ addRequiredParam() [3/6]

template<>

void InputParameters::addRequiredParam	(	const std::string &	name,
		const MooseEnum &	moose_enum,
		const std::string &	doc_string
	)

Definition at line 1213 of file InputParameters.C.

 {
   InputParameters::set<MooseEnum>(name) = moose_enum; // valid parameter is set by set_attributes
   auto & metadata = _params[name];
   metadata._required = true;
   metadata._doc_string = doc_string;
 }

◆ addRequiredParam() [4/6]

template<>

void InputParameters::addRequiredParam	(	const std::string &	name,
		const MultiMooseEnum &	moose_enum,
		const std::string &	doc_string
	)

Definition at line 1225 of file InputParameters.C.

 {
   InputParameters::set<MultiMooseEnum>(name) =
       moose_enum; // valid parameter is set by set_attributes
   auto & metadata = _params[name];
   metadata._required = true;
   metadata._doc_string = doc_string;
 }

◆ addRequiredParam() [5/6]

template<>

void InputParameters::addRequiredParam	(	const std::string &	name,
		const MooseEnum &	moose_enum,
		const std::string &	doc_string
	)

◆ addRequiredParam() [6/6]

template<>

void InputParameters::addRequiredParam	(	const std::string &	name,
		const MultiMooseEnum &	moose_enum,
		const std::string &	doc_string
	)

◆ addRequiredRangeCheckedParam()

template<typename T >

void InputParameters::addRequiredRangeCheckedParam	(	const std::string &	name,
		const std::string &	parsed_function,
		const std::string &	doc_string
	)

These methods add an range checked parameters.

A lower and upper bound can be supplied and the supplied parameter will be checked to fall within that range.

Definition at line 1759 of file InputParameters.h.

Referenced by LogConstantDT::validParams(), AnnularMesh::validParams(), SpiralAnnularMeshGenerator::validParams(), TimeIntervalTimes::validParams(), FixedPointIterationAdaptiveDT::validParams(), SpiralAnnularMesh::validParams(), FillBetweenCurvesGenerator::validParams(), FillBetweenPointVectorsGenerator::validParams(), FillBetweenSidesetsGenerator::validParams(), SphereMeshGenerator::validParams(), FunctorBinnedValuesDivision::validParams(), PseudoTimestep::validParams(), AnnularMeshGenerator::validParams(), MaxIncrement::validParams(), CartesianGridDivision::validParams(), CylindricalGridDivision::validParams(), SphericalGridDivision::validParams(), ParsedCurveGenerator::validParams(), PenaltyEqualValueConstraintTempl< is_ad >::validParams(), and CylinderComponent::validParams().

 {
   addRequiredParam<T>(name, doc_string);
   _params[name]._range_function = parsed_function;
 }

◆ allowCopy()

void InputParameters::allowCopy ( bool status )

inlineprivate

Toggle the availability of the copy constructor.

When MooseObject is created via the Factory this flag is set to false, so when a MooseObject is created if the constructor is not a const reference an error is produced. This method allows the InputParameterWarehouse to disable copying.

Definition at line 1320 of file InputParameters.h.

Referenced by ActionWarehouse::printInputFile().

1320 { _allow_copy = status; }

InputParameters::_allow_copy

bool _allow_copy

A flag for toggling the error message in the copy constructor.

Definition: InputParameters.h:1390

status

MPI_Status status

◆ appendFunctorDescription()

template<typename T >

std::string InputParameters::appendFunctorDescription ( const std::string & doc_string ) const

private

Appends description of what a functor is to a doc string.

Definition at line 2402 of file InputParameters.h.

 {
   auto numeric_value_type = []()
   {
     if constexpr (Moose::internal::isScalarFunctorNameTypeHelper(
                       Moose::internal::getNullptrExample<T>()))
       return "number";
     else if constexpr (Moose::internal::isVectorFunctorNameTypeHelper(
                            Moose::internal::getNullptrExample<T>()))
       return "numeric vector value (enclosed in curly braces)";
     else
     {
       mooseAssert(false, "We control instantiations of this method");
       return "";
     }
   };
 
   return MooseUtils::trim(doc_string, ". ") + ". A functor is any of the following: a variable, " +
          (
 #ifdef MOOSE_MFEM_ENABLED
              Moose::internal::isMFEMFunctorNameTypeHelper(Moose::internal::getNullptrExample<T>())
                  ? "an MFEM"
                  :
 #endif
                  "a functor") +
          " material property, a function, a postprocessor or a " + numeric_value_type() + ".";
 }

◆ applyCoupledVar()

void InputParameters::applyCoupledVar	(	const InputParameters &	common,
		const std::string &	var_name
	)

Apply properties of a single coupled variable in common, to a single coupled variable stored in this object.

Parameters

common	The set of InputParameters from which to extract the coupled variable's properties
var_name	The name of the coupled variable whose properties are to be applied

In order to apply the properties, both the local parameters and the common parameters must have a coupled variable with name var_name

Definition at line 1092 of file InputParameters.C.

Referenced by applyParameters(), and applySpecificParameters().

 {
   // Disable the display of deprecated message when applying common parameters, this avoids a dump
   // of messages
   _show_deprecated_message = false;
 
   // If the local parameters has a coupled variable, populate it with the value from the common
   // parameters, if the common parameters has the coupled variable too
   if (hasCoupledValue(var_name))
   {
     if (common.hasDefaultCoupledValue(var_name))
     {
       // prepare a vector of default coupled values
       std::vector<Real> defaults(common.numberDefaultCoupledValues(var_name));
       for (unsigned int j = 0; j < common.numberDefaultCoupledValues(var_name); ++j)
         defaults[j] = common.defaultCoupledValue(var_name, j);
       addCoupledVar(var_name, defaults, common.getDocString(var_name));
     }
     else if (common.hasCoupledValue(var_name))
       addCoupledVar(var_name, common.getDocString(var_name));
   }
 
   // Enable deprecated message printing
   _show_deprecated_message = true;
 }

◆ applyParameter()

void InputParameters::applyParameter	(	const InputParameters &	common,
		const std::string &	common_name,
		bool	allow_private = `false`,
		bool	override_default = `false`
	)

Apply values from a single parameter in common, to a single parameter stored in this object.

Parameters

common	The set of InputParameters from which to extract parameters from
common_name	The name within common from which to get the parameter values

In order to apply common parameter 4 statements must be satisfied (1) A local parameter must exist with the same name as common parameter (2) Common parameter must valid (3) Local parameter must be invalid OR not have been set from its default (except if override_default is set) (4) Both cannot be private

Definition at line 1119 of file InputParameters.C.

Referenced by ComposeTimeStepperAction::act(), applyParameters(), and applySpecificParameters().

 {
   // Disable the display of deprecated message when applying common parameters, this avoids a dump
   // of messages
   _show_deprecated_message = false;
 
   const auto local_name = checkForRename(common_name);
 
   // Extract the properties from the local parameter for the current common parameter name
   const bool local_exist = _values.find(local_name) != _values.end();
   const bool local_set = _params.count(local_name) > 0 && !_params[local_name]._set_by_add_param;
   const bool local_priv = allow_private ? false : isPrivate(local_name);
   const bool local_valid = isParamValid(local_name);
 
   // Extract the properties from the common parameter
   const bool common_exist = common._values.find(common_name) != common._values.end();
   const bool common_priv = allow_private ? false : common.isPrivate(common_name);
   const bool common_valid = common.isParamValid(common_name) || override_default;
 
   /* In order to apply a common parameter 4 statements must be satisfied
    * (1) A local parameter must exist with the same name as the common parameter
    * (2) Common parameter must be valid and exist
    * (3) Local parameter must be invalid OR not have been set from its default
    * (4) Both cannot be private
    */
   if (local_exist && common_exist && common_valid && (!local_valid || !local_set) &&
       (!common_priv || !local_priv))
   {
     remove(local_name);
     _values[local_name] = common._values.find(common_name)->second->clone();
     set_attributes(local_name, false);
     _params[local_name]._set_by_add_param =
         libmesh_map_find(common._params, common_name)._set_by_add_param;
     // Keep track of where this param came from if we can. This will enable us to
     // produce param errors from objects created within an action that link to
     // the parameter in the action
     at(local_name)._hit_node = common.getHitNode(common_name);
   }
   else if (!local_exist && !common_exist)
     mooseError("InputParameters::applyParameter(): Attempted to apply invalid parameter \"",
                common_name,
                "\"");
 
   // Enable deprecated message printing
   _show_deprecated_message = true;
 }

◆ applyParameters()

void InputParameters::applyParameters	(	const InputParameters &	common,
		const std::vector< std::string > &	exclude = `{}`,
		const bool	allow_private = `false`
	)

Method for applying common parameters.

Parameters

common	The set of parameters to apply to the parameters stored in this object
exclude	A vector of parameters to exclude

In order to apply common parameter 4 statements must be satisfied (1) A local parameter must exist with the same name as common parameter (2) Common parameter must be valid (3) Local parameter must be invalid OR not have been set from its default (4) Both cannot be private (unless allow_private = true)

Output objects have a set of common parameters that are passed down to each of the output objects created. This method is used for applying those common parameters.

See also: CommonOutputAction AddOutputAction

Definition at line 1020 of file InputParameters.C.

Referenced by AddActionComponentAction::act(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addOutput(), SampledOutput::cloneMesh(), DumpObjectsProblem::DumpObjectsProblem(), and ProjectedStatefulMaterialStorageAction::processProperty().

 {
   // If we're applying all of the things, also associate the top level hit node
   if (exclude.empty() && !getHitNode() && common.getHitNode())
     setHitNode(*common.getHitNode(), {});
 
   // Loop through the common parameters
   for (const auto & it : common)
   {
     // Common parameter name
     const std::string & common_name = it.first;
     // Continue to next parameter, if the current is in list of  excluded parameters
     if (std::find(exclude.begin(), exclude.end(), common_name) != exclude.end())
       continue;
 
     applyParameter(common, common_name, allow_private);
   }
 
   // Loop through the coupled variables
   for (std::set<std::string>::const_iterator it = common.coupledVarsBegin();
        it != common.coupledVarsEnd();
        ++it)
   {
     // Variable name
     const std::string var_name = *it;
 
     // Continue to next variable, if the current is in list of  excluded parameters
     if (std::find(exclude.begin(), exclude.end(), var_name) != exclude.end())
       continue;
 
     applyCoupledVar(common, var_name);
   }
 }

◆ applySpecificParameters()

void InputParameters::applySpecificParameters	(	const InputParameters &	common,
		const std::vector< std::string > &	include,
		bool	allow_private = `false`
	)

Method for applying common parameters.

Parameters

common	The set of parameters to apply to the parameters stored in this object
include	A vector of parameters to apply

In order to apply common parameter 4 statements must be satisfied (1) A local parameter must exist with the same name as common parameter (2) Common parameter must valid (3) Local parameter must be invalid OR not have been set from its default (4) Both cannot be private

Output objects have a set of common parameters that are passed down to each of the output objects created. This method is used for applying those common parameters.

See also: CommonOutputAction AddOutputAction

Definition at line 1057 of file InputParameters.C.

Referenced by AddVariableAction::init(), OverlayMeshGenerator::OverlayMeshGenerator(), and ProjectedStatefulMaterialStorageAction::processProperty().

 {
   // Loop through the common parameters
   for (const auto & it : common)
   {
 
     // Common parameter name
     const std::string & common_name = it.first;
 
     // Continue to next parameter, if the current is not in list of included parameters
     if (std::find(include.begin(), include.end(), common_name) == include.end())
       continue;
 
     applyParameter(common, common_name, allow_private);
   }
 
   // Loop through the coupled variables
   for (std::set<std::string>::const_iterator it = common.coupledVarsBegin();
        it != common.coupledVarsEnd();
        ++it)
   {
     // Variable name
     const std::string var_name = *it;
 
     // Continue to next variable, if the current is not in list of included parameters
     if (std::find(include.begin(), include.end(), var_name) == include.end())
       continue;
 
     applyCoupledVar(common, var_name);
   }
 }

◆ areAllRequiredParamsValid()

bool InputParameters::areAllRequiredParamsValid ( ) const

This method returns true if all of the parameters in this object are valid (i.e.

isParamValid(name) == true - for all parameters)

Definition at line 436 of file InputParameters.C.

Referenced by ActionWarehouse::buildBuildableActions().

 {
   for (const auto & it : *this)
     if (isParamRequired(it.first) && !isParamValid(it.first))
       return false;
   return true;
 }

◆ at() [1/2]

Metadata& InputParameters::at ( const std::string & param_name )

inlineprivate

Definition at line 1296 of file InputParameters.h.

Referenced by addCommandLineParamHelper(), applyParameter(), commandLineParamSet(), finalize(), getCommandLineMetadata(), getControllableExecuteOnTypes(), getHitNode(), isCommandLineParameter(), queryCommandLineMetadata(), queryDataFileNamePath(), setGlobalCommandLineParam(), and setHitNode().

   {
     const auto param = checkForRename(param_name);
     if (_params.count(param) == 0)
       mooseError("param '", param, "' not present in InputParams");
     return _params[param];
   }

◆ at() [2/2]

const Metadata& InputParameters::at ( const std::string & param_name ) const

inlineprivate

Definition at line 1303 of file InputParameters.h.

   {
     const auto param = checkForRename(param_name);
     if (_params.count(param) == 0)
       mooseError("param '", param, "' not present in InputParams");
     return _params.at(param);
   }

◆ attemptPrintDeprecated()

bool InputParameters::attemptPrintDeprecated ( const std::string & name )

Prints the deprecated parameter message, assuming we have the right flags set.

Definition at line 110 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   if (_show_deprecated_message)
   {
     auto emit_deprecation_message =
         [this](const auto & deprecated_name, const auto & deprecation_message)
     {
       // This is user-facing, no need for a backtrace
       const auto current_show_trace = Moose::show_trace;
       Moose::show_trace = false;
       moose::internal::mooseDeprecatedStream(
           Moose::out, false, true, errorPrefix(deprecated_name), ":\n", deprecation_message, "\n");
       Moose::show_trace = current_show_trace;
       return true;
     };
 
     if (_params.count(name) && !libmesh_map_find(_params, name)._deprecation_message.empty())
       return emit_deprecation_message(name,
                                       "The parameter '" + name + "' is deprecated.\n" +
                                           libmesh_map_find(_params, name)._deprecation_message);
     else if (auto it = _old_to_new_name_and_dep.find(name_in);
              it != _old_to_new_name_and_dep.end() && !it->second.second.empty())
       return emit_deprecation_message(name_in, it->second.second);
   }
   return false;
 }

◆ blockFullpath()

std::string InputParameters::blockFullpath ( ) const

Returns: A string representing the full HIT parameter path from the input file (e.g. "Mesh/foo") for the block containing parameters for this object.

Definition at line 1508 of file InputParameters.C.

Referenced by AddFVICAction::act(), AddICAction::act(), AddAuxKernelAction::act(), AddActionComponentAction::AddActionComponentAction(), checkParams(), MooseBaseParameterInterface::getRenamedParam(), MooseApp::getRenamedParam(), MooseObjectAction::MooseObjectAction(), FVRelationshipManagerInterface::parameterError(), and NEML2Action::printSummary().

 {
   if (const auto hit_node = getHitNode())
     return hit_node->fullpath();
   return "";
 }

◆ blockLocation()

std::string InputParameters::blockLocation ( ) const

Returns: A string representing the location (i.e. filename,linenum) in the input text for the block containing parameters for this object.

Definition at line 1500 of file InputParameters.C.

Referenced by checkParams().

 {
   if (const auto hit_node = getHitNode())
     return hit_node->fileLocation(/* with_column = */ false);
   return "";
 }

◆ callMooseErrorHelper()

void InputParameters::callMooseErrorHelper	(	const MooseBase &	moose_base,
		const std::string &	error
	)

staticprivate

Definition at line 1754 of file InputParameters.C.

Referenced by getParamHelper().

 {
   moose_base.callMooseError(error, true);
 }

◆ checkConsistentType()

template<typename T >

void InputParameters::checkConsistentType ( const std::string & name ) const

This method checks to make sure that we aren't adding a parameter with the same name but a different type.

It throws a MooseError if an inconsistent type is detected. While this state is supported by libMesh it brings nothing but blood and tears for those who try ;)

Parameters

name	the name of the parameter

Definition at line 1921 of file InputParameters.h.

 {
   const auto name = checkForRename(name_in);
 
   // If we don't currently have the Parameter, can't be any inconsistency
   InputParameters::const_iterator it = _values.find(name);
   if (it == _values.end())
     return;
 
   // Now, if we already have the Parameter, but it doesn't have the
   // right type, throw an error.
   if (!this->Parameters::have_parameter<T>(name))
     mooseError("Attempting to set parameter \"",
                name,
                "\" with type (",
                libMesh::demangle(typeid(T).name()),
                ")\nbut the parameter already exists as type (",
                it->second->type(),
                ")");
 }

◆ checkForRename()

std::string InputParameters::checkForRename ( const std::string & name ) const

Checks whether the provided name is a renamed parameter name.

If so we return the 'new' name. If not we return the incoming name

Parameters

name	The name to check for whether it is a renamed name

Returns: The new name if the incoming name is a renamed name, else name

Definition at line 1726 of file InputParameters.C.

Referenced by applyParameter(), at(), attemptPrintDeprecated(), checkConsistentType(), checkParams(), ScalarCoupleable::checkVar(), Coupleable::checkVar(), commandLineParamSet(), Coupleable::coupledComponents(), ScalarCoupleable::coupledScalarComponents(), declareControllable(), defaultCoupledValue(), get(), getCheckedPointerParam(), getCommandLineMetadata(), getControllableExecuteOnTypes(), getDescription(), getDocString(), getDocUnit(), getGroupName(), getMooseType(), getParamHelper(), ScalarCoupleable::getScalarVar(), Coupleable::getVarHelper(), getVecMooseType(), hasDefault(), have_parameter(), ignoreParameter(), isCommandLineParameter(), isControllable(), Coupleable::isCoupled(), ScalarCoupleable::isCoupledScalar(), isParamDefined(), isParamDeprecated(), isParamRequired(), isParamSetByAddParam(), isParamSetByUser(), isParamValid(), isPrivate(), isRangeChecked(), isType(), makeParamNotRequired(), makeParamRequired(), queryCommandLineMetadata(), queryDataFileNamePath(), rangeCheckedFunction(), reservedValues(), set(), set_attributes(), setDocString(), setDocUnit(), setGlobalCommandLineParam(), setReservedValues(), shouldIgnore(), suppressParameter(), transferParam(), and type().

 {
   if (auto it = _old_to_new_name_and_dep.find(name); it != _old_to_new_name_and_dep.end())
     return it->second.first;
   else
     return name;
 }

◆ checkParamName()

void InputParameters::checkParamName ( const std::string & name ) const

private

Make sure the parameter name doesn't have any invalid characters.

Definition at line 1547 of file InputParameters.C.

Referenced by addParam(), addPrivateParam(), addRequiredParam(), and set().

 {
   const static pcrecpp::RE valid("[\\w:/]+");
   if (!valid.FullMatch(name))
     mooseError("Invalid parameter name: '", name, "'");
 }

◆ checkParams()

void InputParameters::checkParams ( const std::string & parsing_syntax )

This function checks parameters stored in the object to make sure they are in the correct state as the user expects: Required parameters are verified as valid meaning that they were either initialized when they were created, or were read from an input file or some other valid source.

Definition at line 592 of file InputParameters.C.

Referenced by FEProblemBase::addFVInitialCondition(), FEProblemBase::addInitialCondition(), and finalize().

 {
   std::string parampath = blockFullpath() != "" ? blockFullpath() : parsing_syntax;
   std::ostringstream oss;
   // Required parameters
   for (const auto & it : *this)
   {
     const auto param_name = checkForRename(it.first);
     if (!isParamValid(param_name) && isParamRequired(param_name))
     {
       // check if an old, deprecated name exists for this parameter that may be specified
       auto oit = _new_to_deprecated_coupled_vars.find(param_name);
       if (oit != _new_to_deprecated_coupled_vars.end() && isParamValid(oit->second))
         continue;
 
       oss << blockLocation() << ": missing required parameter '" << parampath + "/" + param_name
           << "'\n";
       oss << "\tDoc String: \"" + getDocString(param_name) + "\"" << std::endl;
     }
   }
 
   // Range checked parameters
   for (const auto & it : *this)
   {
     std::string long_name(parampath + "/" + it.first);
 
     dynamicCastRangeCheck(Real, Real, long_name, it.first, it.second, oss);
     dynamicCastRangeCheck(int, long, long_name, it.first, it.second, oss);
     dynamicCastRangeCheck(long, long, long_name, it.first, it.second, oss);
     dynamicCastRangeCheck(unsigned int, long, long_name, it.first, it.second, oss);
   }
 
   // Controllable parameters
   for (const auto & param_name : getControllableParameters())
   {
     if (isPrivate(param_name))
       oss << inputLocation(param_name) << ": private parameter '" << paramFullpath(param_name)
           << "' marked controllable";
 
     checkMooseType(NonlinearVariableName, param_name);
     checkMooseType(AuxVariableName, param_name);
     checkMooseType(VariableName, param_name);
     checkMooseType(BoundaryName, param_name);
     checkMooseType(SubdomainName, param_name);
     checkMooseType(PostprocessorName, param_name);
     checkMooseType(VectorPostprocessorName, param_name);
     checkMooseType(UserObjectName, param_name);
     checkMooseType(MaterialPropertyName, param_name);
   }
 
   if (!oss.str().empty())
     mooseError(oss.str());
 }

◆ clear()

void InputParameters::clear ( )

overridevirtual

Reimplemented from libMesh::Parameters.

Definition at line 63 of file InputParameters.C.

 {
   Parameters::clear();
   _params.clear();
   _coupled_vars.clear();
   _new_to_deprecated_coupled_vars.clear();
   _collapse_nesting = false;
   _moose_object_syntax_visibility = true;
   _show_deprecated_message = true;
   _allow_copy = true;
   _block_fullpath = "";
   _block_location = "";
   _old_to_new_name_and_dep.clear();
   _new_to_old_names.clear();
   _hit_node = nullptr;
   _finalized = false;
 }

◆ clearRelationshipManagers()

void InputParameters::clearRelationshipManagers ( )

inline

Clears all currently registered RelationshipManagers.

Definition at line 737 of file InputParameters.h.

Referenced by ElemSideNeighborLayersGeomTester::validParams().

737 { _buildable_rm_types.clear(); }

InputParameters::_buildable_rm_types

std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > _buildable_rm_types

The RelationshipManagers that this object may either build or require.

Definition: InputParameters.h:1376

◆ collapseSyntaxNesting() [1/2]

void InputParameters::collapseSyntaxNesting ( bool collapse )

Mutators for controlling whether or not the outermost level of syntax will be collapsed when printed.

Definition at line 549 of file InputParameters.C.

Referenced by Moose::Builder::buildFullTree(), and Moose::Builder::buildJsonSyntaxTree().

 {
   _collapse_nesting = collapse;
 }

◆ collapseSyntaxNesting() [2/2]

bool InputParameters::collapseSyntaxNesting ( ) const

Definition at line 555 of file InputParameters.C.

 {
   return _collapse_nesting;
 }

◆ commandLineParamSet()

void InputParameters::commandLineParamSet	(	const std::string &	name,
		const CommandLineParamSetKey
	)

Marks the command line parameter name as set by the CommandLine.

Protected by the CommandLineParamSetKey so that only the CommandLine can call this.

Definition at line 999 of file InputParameters.C.

 {
   auto & cl_data = at(checkForRename(name))._cl_data;
   if (!cl_data)
     mooseError("InputParameters::commandLineParamSet: The parameter '",
                name,
                "' is not a command line parameter");
   cl_data->set_by_command_line = true;
 }

◆ coupledVarsBegin()

std::set<std::string>::const_iterator InputParameters::coupledVarsBegin ( ) const

inline

Methods returning iterators to the coupled variables names stored in this InputParameters object.

Definition at line 817 of file InputParameters.h.

Referenced by Coupleable::Coupleable(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), LazyCoupleable::LazyCoupleable(), and ScalarCoupleable::ScalarCoupleable().

   {
     return _coupled_vars.begin();
   }

◆ coupledVarsEnd()

std::set<std::string>::const_iterator InputParameters::coupledVarsEnd ( ) const

inline

Definition at line 821 of file InputParameters.h.

Referenced by Coupleable::Coupleable(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), LazyCoupleable::LazyCoupleable(), and ScalarCoupleable::ScalarCoupleable().

   {
     return _coupled_vars.end();
   }

◆ declareControllable()

void InputParameters::declareControllable	(	const std::string &	name,
		std::set< ExecFlagType >	execute_flags = `{}`
	)

Declare the given parameters as controllable.

Definition at line 452 of file InputParameters.C.

Referenced by GenericConstant2DArray::validParams(), PenaltyDirichletNodalKernel::validParams(), GenericConstantArray::validParams(), GenericConstantVectorMaterialTempl< is_ad >::validParams(), ConstantScalarAux::validParams(), ConstantFunction::validParams(), ConstantPostprocessor::validParams(), ConstantAux::validParams(), ReactionTempl< is_ad >::validParams(), ConstantPointSource::validParams(), DirichletBC::validParams(), NeumannBCTempl< is_ad >::validParams(), ADDirichletBC::validParams(), VectorDirichletBC::validParams(), ArrayDirichletBC::validParams(), VectorConstantPointSource::validParams(), ConstantRate::validParams(), PiecewiseTabularBase::validParams(), PiecewiseLinearInterpolationMaterial::validParams(), FunctionValuePostprocessor::validParams(), FVBodyForce::validParams(), VectorBodyForce::validParams(), TimeStepper::validParams(), TorchScriptUserObject::validParams(), GenericConstantMaterialTempl< is_ad >::validParams(), BodyForceTempl< is_ad >::validParams(), Damper::validParams(), InterfaceKernelBase::validParams(), DiracKernelBase::validParams(), IterationAdaptiveDT::validParams(), PenaltyDirichletBC::validParams(), ADPenaltyDirichletBC::validParams(), AuxScalarKernel::validParams(), Output::validParams(), UserObject::validParams(), LinearFVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), FVBoundaryCondition::validParams(), AuxKernelTempl< Real >::validParams(), MultiApp::validParams(), and FEProblemBase::validParams().

 {
   std::vector<std::string> names;
   MooseUtils::tokenize<std::string>(input_names, names, 1, " ");
   for (auto & name_in : names)
   {
     const auto name = checkForRename(name_in);
     auto map_iter = _params.find(name);
     if (map_iter != _params.end()) // error is handled by checkParams method
     {
       map_iter->second._controllable = true;
       map_iter->second._controllable_flags = execute_flags;
     }
     else
       mooseError("The input parameter '",
                  name,
                  "' does not exist, thus cannot be marked as controllable.");
   }
 }

◆ defaultCoupledValue() [1/2]

Real InputParameters::defaultCoupledValue	(	const std::string &	coupling_name,
		unsigned int	i = `0`
	)		const

Get the default value for an optionally coupled variable.

Parameters

coupling_name	The name of the coupling parameter to get the default value for.
i	By default 0, in general the index of the requested coupled default value.

Definition at line 811 of file InputParameters.C.

Referenced by applyCoupledVar(), ScalarCoupleable::getADDefaultValue(), Coupleable::getADDefaultValue(), Coupleable::getADDefaultVectorValue(), Coupleable::getDefaultArrayValue(), ScalarCoupleable::getDefaultValue(), Coupleable::getDefaultValue(), Coupleable::getDefaultVectorValue(), and transferParam().

 {
   auto value_it = _params.find(coupling_name);
 
   if (value_it == _params.end() || !value_it->second._have_coupled_default)
     mooseError("Attempted to retrieve default value for coupled variable '",
                coupling_name,
                "' when none was provided. \n\nThere are three reasons why this may have "
                "occurred:\n 1. The other version of params.addCoupledVar() should be used in order "
                "to provide a default value. \n 2. This should have been a required coupled "
                "variable added with params.addRequiredCoupledVar() \n 3. The call to get the "
                "coupled value should have been properly guarded with isCoupled()\n");
 
   return value_it->second._coupled_default.at(i);
 }

◆ defaultCoupledValue() [2/2]

void InputParameters::defaultCoupledValue	(	const std::string &	coupling_name,
		Real	value,
		unsigned int	i = `0`
	)

Set the default value for an optionally coupled variable (called by the Parser).

Parameters

coupling_name	The name of the coupling parameter to get the default value for.
value	Default value to set.
i	By default 0, in general the index of the requested coupled default value.

Definition at line 802 of file InputParameters.C.

 {
   const auto actual_name = checkForRename(coupling_name);
   _params[actual_name]._coupled_default.resize(i + 1);
   _params[actual_name]._coupled_default[i] = value;
   _params[actual_name]._have_coupled_default = true;
 }

◆ deprecateCoupledVar()

void InputParameters::deprecateCoupledVar	(	const std::string &	old_name,
		const std::string &	new_name,
		const std::string &	removal_date
	)

Definition at line 1718 of file InputParameters.C.

Referenced by DerivativeSumMaterialTempl< is_ad >::validParams(), ParsedODEKernel::validParams(), ParsedMaterialBase::validParams(), ParsedAux::validParams(), CoupledGradientMaterialTempl< is_ad >::validParams(), MaterialDerivativeTestKernelBase< Real >::validParams(), CompositeTensorBase< T, U >::validParams(), and ConservativeAdvectionTempl< is_ad >::validParams().

 {
   renameCoupledVarInternal(old_name, new_name, "", removal_date);
 }

◆ deprecateParam()

void InputParameters::deprecateParam	(	const std::string &	old_name,
		const std::string &	new_name,
		const std::string &	removal_date
	)

Definition at line 1710 of file InputParameters.C.

Referenced by SideSetsFromNormalsGenerator::validParams(), ParsedPostprocessor::validParams(), ParsedAux::validParams(), ParsedODEKernel::validParams(), CoupledGradientMaterialTempl< is_ad >::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), MatReaction::validParams(), CommonOutputAction::validParams(), SideSetsGeneratorBase::validParams(), ConservativeAdvectionTempl< is_ad >::validParams(), Output::validParams(), and MultiApp::validParams().

 {
   renameParamInternal(old_name, new_name, "", removal_date);
 }

◆ errorPrefix()

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

generate error message prefix with parameter name and location (if available)

Definition at line 1594 of file InputParameters.C.

Referenced by attemptPrintDeprecated(), finalize(), get(), getFileBase(), and paramErrorPrefix().

 {
   auto prefix = param + ":";
   if (!inputLocation(param).empty())
     prefix = inputLocation(param) + ": (" + paramFullpath(param) + ")";
   return prefix;
 }

◆ finalize()

void InputParameters::finalize ( const std::string & parsing_syntax )

Finalizes the parameters, which must be done before constructing any objects with these parameters (to be called in the corresponding factories).

typed parameters.

This calls checkParams() and sets up the absolute paths for all file name.

Definition at line 647 of file InputParameters.C.

Referenced by Factory::initialize().

 {
   mooseAssert(!isFinalized(), "Already finalized");
 
   checkParams(parsing_syntax);
 
   // Helper for setting the absolute paths for each set file name parameter
   const auto set_absolute_path = [this](const std::string & param_name, auto & value)
   {
     // We don't need to set a path if nothing is there
     if (value.empty())
       return;
 
     std::filesystem::path value_path = std::string(value);
     // Is already absolute, nothing to do
     if (value_path.is_absolute())
       return;
 
     // The base by which to make things relative to
     const auto file_base = getFileBase(param_name);
     value = std::filesystem::absolute(file_base / value_path).c_str();
   };
 
   // Set the absolute path for each file name typed parameter
   for (const auto & [param_name, param_value] : *this)
   {
 #define set_if_filename(type)                                                                      \
   else if (auto type_value = dynamic_cast<Parameters::Parameter<type> *>(param_value.get()))       \
       set_absolute_path(param_name, type_value->set());                                            \
   else if (auto type_values = dynamic_cast<Parameters::Parameter<std::vector<type>> *>(            \
                param_value.get())) for (auto & value : type_values->set())                         \
       set_absolute_path(param_name, value)
 
     if (false)
       ;
     // Note that we explicitly skip DataFileName here because we do not want absolute
     // file paths for data files, as they're searched in the data directories
     set_if_filename(FileName);
     set_if_filename(FileNameNoExtension);
     set_if_filename(MeshFileName);
     set_if_filename(MatrixFileName);
 #undef set_if_filename
     // Set paths for data files
     else if (auto data_file_name =
                  dynamic_cast<Parameters::Parameter<DataFileName> *>(param_value.get()))
     {
       Moose::DataFileUtils::Path found_path;
       std::optional<std::string> error;
 
       // Catch this so that we can add additional error context if it fails (the param path)
       const auto throw_on_error_before = Moose::_throw_on_error;
       Moose::_throw_on_error = true;
       try
       {
         found_path = Moose::DataFileUtils::getPath(data_file_name->get(), getFileBase(param_name));
       }
       catch (std::exception & e)
       {
         error = errorPrefix(param_name) + " " + e.what();
       }
       Moose::_throw_on_error = throw_on_error_before;
 
       if (error)
         mooseError(*error);
 
       // Set the value to the absolute searched path
       data_file_name->set() = found_path.path;
       // And store the path in metadata so that we can dump it later
       at(param_name)._data_file_name_path = found_path;
     }
   }
 
   _finalized = true;
 }

◆ get() [1/2]

template<typename R1 , typename R2 , typename V1 , typename V2 >

std::vector< std::pair< R1, R2 > > InputParameters::get	(	const std::string &	param1,
		const std::string &	param2
	)		const

Combine two vector parameters into a single vector of pairs.

Definition at line 2172 of file InputParameters.h.

 {
   const auto param1 = checkForRename(param1_in);
   const auto param2 = checkForRename(param2_in);
 
   const auto & v1 = get<V1>(param1);
   const auto & v2 = get<V2>(param2);
 
   auto controllable = getControllableParameters();
   if (controllable.count(param1) || controllable.count(param2))
     mooseError(errorPrefix(param1),
                " and/or ",
                errorPrefix(param2) +
                    " are controllable parameters and cannot be retireved using "
                    "the MooseObject::getParam/InputParameters::get methods for pairs");
 
   if (v1.size() != v2.size())
     mooseError("Vector parameters ",
                errorPrefix(param1),
                "(size: ",
                v1.size(),
                ") and " + errorPrefix(param2),
                "(size: ",
                v2.size(),
                ") are of different lengths \n");
 
   std::vector<std::pair<R1, R2>> parameter_pairs;
   auto i1 = v1.begin();
   auto i2 = v2.begin();
   for (; i1 != v1.end() && i2 != v2.end(); ++i1, ++i2)
     parameter_pairs.emplace_back(std::make_pair(*i1, *i2));
   return parameter_pairs;
 }

◆ get() [2/2]

template<typename T >

const T & InputParameters::get ( std::string_view name ) const

A wrapper around the Parameters base class method.

Checks for parameter rename before calling the base class method

Parameters

name	The name to query the parameter values map with

Returns: The parameter value corresponding to the (possibly renamed) name

Definition at line 2221 of file InputParameters.h.

 {
   const auto name = checkForRename(std::string(name_in));
 
   return Parameters::get<T>(name);
 }

◆ getAutoBuildVectors()

std::map< std::string, std::pair< std::string, std::string > > InputParameters::getAutoBuildVectors ( ) const

Returns the auto build vectors for all parameters.

Definition at line 839 of file InputParameters.C.

 {
   std::map<std::string, std::pair<std::string, std::string>> abv;
   for (auto it = _params.begin(); it != _params.end(); ++it)
   {
     if (!it->second._autobuild_vecs.first.empty())
       abv[it->first] = it->second._autobuild_vecs;
   }
   return abv;
 }

◆ getBase()

std::optional< std::string > InputParameters::getBase ( ) const

Returns: The base system of the object these parameters are for, if any

Definition at line 495 of file InputParameters.C.

Referenced by MooseBase::errorPrefix().

 {
   if (have_parameter<std::string>("_moose_base"))
     return get<std::string>("_moose_base");
   return {};
 }

◆ getBuildableRelationshipManagerTypes()

const std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > & InputParameters::getBuildableRelationshipManagerTypes ( ) const

Returns the list of buildable (or required) RelationshipManager object types for this object.

Definition at line 543 of file InputParameters.C.

Referenced by Action::addRelationshipManagers().

 {
   return _buildable_rm_types;
 }

◆ getBuildableTypes()

const std::vector< std::string > & InputParameters::getBuildableTypes ( ) const

Returns the list of buildable types as a std::vector<std::string>

Definition at line 535 of file InputParameters.C.

Referenced by Moose::Builder::buildFullTree(), and Moose::Builder::buildJsonSyntaxTree().

 {
   return _buildable_types;
 }

◆ getCheckedPointerParam()

template<typename T >

T InputParameters::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.

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

Definition at line 1612 of file InputParameters.h.

Referenced by Coupleable::Coupleable(), Postprocessor::declareValue(), MooseBaseParameterInterface::getCheckedPointerParam(), ElementIDInterface::getElementID(), ElementIDInterface::getElementIDByName(), ElementIDInterface::getElementIDNeighbor(), ElementIDInterface::getElementIDNeighborByName(), MooseVariableInterface< Real >::MooseVariableInterface(), ScalarCoupleable::ScalarCoupleable(), and TaggingInterface::TaggingInterface().

 {
   const auto name = checkForRename(name_in);
 
   T param = this->get<T>(name);
 
   // Note: You will receive a compile error on this line if you attempt to pass a non-pointer
   // template type to this method
   if (param == NULL)
     mooseError("Parameter ", name, " is NULL.\n", error_string);
   return this->get<T>(name);
 }

◆ getClassDescription()

std::string InputParameters::getClassDescription ( ) const

Returns the class description.

Definition at line 139 of file InputParameters.C.

Referenced by JsonSyntaxTree::addParameters(), MooseServer::addValuesToList(), and MooseServer::getHoverDisplayText().

 {
   return _class_description;
 }

◆ getCommandLineMetadata()

const InputParameters::CommandLineMetadata & InputParameters::getCommandLineMetadata ( const std::string & name ) const

Returns: The command line metadata for the parameter name.

Definition at line 988 of file InputParameters.C.

Referenced by MooseApp::copyInputs(), and MooseApp::showInputs().

 {
   const auto & cl_data = at(checkForRename(name))._cl_data;
   if (!cl_data)
     mooseError("InputParameters::getCommandLineMetadata: The parameter '",
                name,
                "' is not a command line parameter");
   return *cl_data;
 }

◆ getControllableExecuteOnTypes()

const std::set< ExecFlagType > & InputParameters::getControllableExecuteOnTypes ( const std::string & name ) const

Return the allowed execute flags for a controllable parameter.

Definition at line 481 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   return at(name)._controllable_flags;
 }

◆ getControllableParameters()

std::set< std::string > InputParameters::getControllableParameters ( ) const

Return list of controllable parameters.

Definition at line 1584 of file InputParameters.C.

Referenced by checkParams(), and get().

 {
   std::set<std::string> controllable;
   for (auto it = _params.begin(); it != _params.end(); ++it)
     if (it->second._controllable)
       controllable.emplace(it->first);
   return controllable;
 }

◆ getCoupledVariableParamNames()

const std::set<std::string>& InputParameters::getCoupledVariableParamNames ( ) const

inline

Return the coupled variable parameter names.

Definition at line 829 of file InputParameters.h.

829 { return _coupled_vars; }

InputParameters::_coupled_vars

std::set< std::string > _coupled_vars

The coupled variables set.

Definition: InputParameters.h:1359

◆ getDescription()

const std::string & InputParameters::getDescription ( const std::string & name ) const

Get the documentation string for a parameter.

Definition at line 1202 of file InputParameters.C.

Referenced by transferParam().

 {
   const auto name = checkForRename(name_in);
   auto it = _params.find(name);
   if (it == _params.end())
     mooseError("No parameter exists with the name ", name);
   return it->second._doc_string;
 }

◆ getDocString()

std::string InputParameters::getDocString ( const std::string & name ) const

Returns the documentation string for the specified parameter name.

Definition at line 328 of file InputParameters.C.

Referenced by applyCoupledVar(), checkParams(), and MooseServer::getHoverDisplayText().

 {
   const auto name = checkForRename(name_in);
 
   std::string doc_string;
   auto it = _params.find(name);
   if (it != _params.end())
     for (const auto & ch : it->second._doc_string)
     {
       if (ch == '\n')
         doc_string += " ... ";
       else
         doc_string += ch;
     }
 
   return doc_string;
 }

◆ getDocUnit()

std::string InputParameters::getDocUnit ( const std::string & name ) const

Returns the documentation unit string for the specified parameter name.

Definition at line 360 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   return _params.at(name)._doc_unit;
 }

◆ getFileBase()

std::filesystem::path InputParameters::getFileBase ( const std::optional< std::string > & param_name = std::optional<std::string>() ) const

Returns: A file base to associate with these parameters.

Optionally, an input parameter can be provided via param_name.

If the parameter is provided, we have the following options:

The parameter itself has a hit node set (context for that parameter)
The InputParameters object has a hit node set (context for all parameters)
Neither of the above and we die

In the event that a the parameter is set via command line, this will attempt to look at the parameter's parents to find a suitable context.

Definition at line 723 of file InputParameters.C.

Referenced by finalize().

 {
   mooseAssert(!have_parameter<std::string>("_app_name"),
               "Not currently setup to work with app FileName parameters");
 
   const hit::Node * hit_node = nullptr;
 
   // Context from the individual parameter
   if (param_name)
     hit_node = getHitNode(*param_name);
   // Context from the parameters
   if (!hit_node)
     hit_node = getHitNode();
   // No hit node, so use the cwd (no input files)
   if (!hit_node)
     return std::filesystem::current_path();
 
   // Find any context that isn't command line arguments
   while (hit_node && hit_node->filename() == "CLI_ARGS")
     hit_node = hit_node->parent();
 
   // Failed to find a node up the tree that isn't a command line argument
   if (!hit_node)
   {
     std::string prefix = "";
     if (param_name)
       prefix = errorPrefix(*param_name) + " ";
     mooseError(prefix,
                "Input context was set via a command-line argument and does not have sufficient "
                "context for "
                "determining a file path.");
   }
 
   return std::filesystem::absolute(std::filesystem::path(hit_node->filename()).parent_path());
 }

◆ getGroupName()

std::string InputParameters::getGroupName ( const std::string & param_name ) const

This method retrieves the group name for the passed parameter name if one exists.

Otherwise an empty string is returned.

Definition at line 1010 of file InputParameters.C.

 {
   const auto param_name = checkForRename(param_name_in);
   auto it = _params.find(param_name);
   if (it != _params.end())
     return it->second._group;
   return std::string();
 }

◆ getGroupParameters()

std::set< std::string > InputParameters::getGroupParameters ( const std::string & group ) const

Return names of parameters within a group.

Definition at line 1565 of file InputParameters.C.

 {
   std::set<std::string> names;
   for (auto it = _params.begin(); it != _params.end(); ++it)
     if (it->second._group == group)
       names.emplace(it->first);
   return names;
 }

◆ getHitNode() [1/2]

const hit::Node * InputParameters::getHitNode ( const std::string & param ) const

Returns: The hit node associated with setting the parameter param, if any

Definition at line 1516 of file InputParameters.C.

Referenced by applyParameter(), applyParameters(), Action::associateWithParameter(), MooseBase::errorPrefix(), ActionWarehouse::getCurrentActionName(), and Factory::initialize().

 {
   return at(param)._hit_node;
 }

◆ getHitNode() [2/2]

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

inline

Returns: The hit node that represents the syntax responsible for creating these parameters, if any

Definition at line 1195 of file InputParameters.h.

Referenced by applyParameters(), blockFullpath(), blockLocation(), getFileBase(), inputLocation(), paramFullpath(), and rawParamVal().

1195 { return _hit_node; }

InputParameters::_hit_node

const hit::Node * _hit_node

The hit node representing the syntax that created these parameters, if any.

Definition: InputParameters.h:1406

◆ getMooseType()

std::string InputParameters::getMooseType ( const std::string & name ) const

Utility functions for retrieving one of the MooseTypes variables into the common "string" base class.

Scalar and Vector versions are supplied

Definition at line 865 of file InputParameters.C.

Referenced by MooseObjectWarehouseBase< Indicator >::addObject(), BlockRestrictable::initializeBlockRestrictable(), isValid(), and varName().

 {
   const auto name = checkForRename(name_in);
   std::string var;
 
   if (have_parameter<VariableName>(name))
     var = get<VariableName>(name);
   else if (have_parameter<NonlinearVariableName>(name))
     var = get<NonlinearVariableName>(name);
   else if (have_parameter<LinearVariableName>(name))
     var = get<LinearVariableName>(name);
   else if (have_parameter<AuxVariableName>(name))
     var = get<AuxVariableName>(name);
   else if (have_parameter<PostprocessorName>(name))
     var = get<PostprocessorName>(name);
   else if (have_parameter<VectorPostprocessorName>(name))
     var = get<VectorPostprocessorName>(name);
   else if (have_parameter<FunctionName>(name))
     var = get<FunctionName>(name);
   else if (have_parameter<UserObjectName>(name))
     var = get<UserObjectName>(name);
   else if (have_parameter<MaterialPropertyName>(name))
     var = get<MaterialPropertyName>(name);
   else if (have_parameter<std::string>(name))
     var = get<std::string>(name);
 
   return var;
 }

◆ getNewToDeprecatedVarMap()

const std::unordered_map<std::string, std::string>& InputParameters::getNewToDeprecatedVarMap ( ) const

inline

Return the new to deprecated variable name map.

Definition at line 834 of file InputParameters.h.

   {
     return _new_to_deprecated_coupled_vars;
   }

◆ getParametersList()

std::set< std::string > InputParameters::getParametersList ( ) const

Returns: list of all parameters

Definition at line 1575 of file InputParameters.C.

Referenced by MooseServer::gatherDocumentCompletionItems(), and MooseServer::getHoverDisplayText().

 {
   std::set<std::string> param_set;
   for (auto it = _params.begin(); it != _params.end(); ++it)
     param_set.emplace(it->first);
   return param_set;
 }

◆ getParamHelper() [1/5]

template<typename T >

const T & InputParameters::getParamHelper	(	const std::string &	name,
		const InputParameters &	pars,
		const T *	the_type,
		const MooseBase *	moose_base = `nullptr`
	)

static

Definition at line 2133 of file InputParameters.h.

Referenced by MooseBaseParameterInterface::getParam(), MooseApp::getParam(), MooseBaseParameterInterface::getRenamedParam(), and MooseApp::getRenamedParam().

 {
   const auto name = pars.checkForRename(name_in);
 
   if (!pars.isParamValid(name))
   {
     std::stringstream err;
     err << "The parameter \"" << name << "\" is being retrieved before being set.";
     if (moose_base)
       callMooseErrorHelper(*moose_base, err.str());
     else
       mooseError(err.str());
   }
 
   return pars.get<T>(name);
 }

◆ getParamHelper() [2/5]

template<>

const MooseEnum& InputParameters::getParamHelper	(	const std::string &	name_in,
		const InputParameters &	pars,
		const MooseEnum *	,
		const MooseBase *
	)

Definition at line 1461 of file InputParameters.C.

 {
   const auto name = pars.checkForRename(name_in);
   return pars.get<MooseEnum>(name);
 }

◆ getParamHelper() [3/5]

template<>

const MultiMooseEnum& InputParameters::getParamHelper	(	const std::string &	name_in,
		const InputParameters &	pars,
		const MultiMooseEnum *	,
		const MooseBase *
	)

Definition at line 1472 of file InputParameters.C.

 {
   const auto name = pars.checkForRename(name_in);
   return pars.get<MultiMooseEnum>(name);
 }

◆ getParamHelper() [4/5]

template<>

const MooseEnum& InputParameters::getParamHelper	(	const std::string &	name,
		const InputParameters &	pars,
		const MooseEnum *	,
		const MooseBase *	moose_base
	)

◆ getParamHelper() [5/5]

template<>

const MultiMooseEnum& InputParameters::getParamHelper	(	const std::string &	name,
		const InputParameters &	pars,
		const MultiMooseEnum *	,
		const MooseBase *	moose_base
	)

◆ getSystemAttributeName()

const std::string & InputParameters::getSystemAttributeName ( ) const

Get the system attribute name if it was registered.

Otherwise throw an error. See the AttribSystem object for use Attribute.h/C.

Definition at line 510 of file InputParameters.C.

Referenced by AttribSystem::initFrom().

 {
   mooseAssert(have_parameter<std::string>("_moose_warehouse_system_name"),
               "SystemAttributeName is not available! Call 'registerSystemAttributeName' (usually "
               "in the validParams function) before you try accessing it!");
   return Parameters::get<std::string>("_moose_warehouse_system_name");
 }

◆ getVecMooseType()

std::vector< std::string > InputParameters::getVecMooseType ( const std::string & name ) const

Definition at line 895 of file InputParameters.C.

Referenced by MooseObjectWarehouseBase< Indicator >::addObject(), Coupleable::Coupleable(), isValid(), ScalarCoupleable::ScalarCoupleable(), and varName().

 {
   const auto name = checkForRename(name_in);
   std::vector<std::string> svars;
 
   if (have_parameter<std::vector<VariableName>>(name))
   {
     std::vector<VariableName> vars = get<std::vector<VariableName>>(name);
     std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
   }
   else if (have_parameter<std::vector<NonlinearVariableName>>(name))
   {
     std::vector<NonlinearVariableName> vars = get<std::vector<NonlinearVariableName>>(name);
     std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
   }
   else if (have_parameter<std::vector<AuxVariableName>>(name))
   {
     std::vector<AuxVariableName> vars = get<std::vector<AuxVariableName>>(name);
     std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
   }
   else if (have_parameter<std::vector<MaterialPropertyName>>(name))
   {
     std::vector<MaterialPropertyName> vars = get<std::vector<MaterialPropertyName>>(name);
     std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
   }
   else if (have_parameter<std::vector<std::string>>(name))
   {
     std::vector<std::string> vars = get<std::vector<std::string>>(name);
     std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
   }
 
   return svars;
 }

◆ hasCoupledValue()

bool InputParameters::hasCoupledValue ( const std::string & coupling_name ) const

Return whether or not the coupled variable exists.

Parameters

coupling_name The name of the coupled variable to test for

Returns: True if the variable exists in the coupled variables for this InputParameters object

Definition at line 789 of file InputParameters.C.

Referenced by applyCoupledVar(), Coupleable::isCoupled(), ScalarCoupleable::isCoupledScalar(), and transferParam().

 {
   return _coupled_vars.find(coupling_name) != _coupled_vars.end();
 }

◆ hasDefault()

bool InputParameters::hasDefault ( const std::string & param_name ) const

Return whether a parameter has a default.

Definition at line 774 of file InputParameters.C.

Referenced by transferParam().

 {
   const auto name = checkForRename(param_name);
   if (hasDefaultCoupledValue(name))
     return true;
   // If it has a default, it's already valid
   else if (isParamSetByAddParam(name))
     return true;
   else if (isParamValid(name))
     mooseError("No way to know if the parameter '", param_name, "' has a default");
   else
     return false;
 }

◆ hasDefaultCoupledValue()

bool InputParameters::hasDefaultCoupledValue ( const std::string & coupling_name ) const

Return whether or not the requested parameter has a default coupled value.

Parameters

coupling_name The name of the coupling parameter to get the default value for.

Definition at line 795 of file InputParameters.C.

Referenced by applyCoupledVar(), Coupleable::coupledComponents(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), hasDefault(), Coupleable::isCoupledConstant(), and transferParam().

 {
   return _params.count(coupling_name) > 0 && _params.at(coupling_name)._have_coupled_default &&
          _coupled_vars.count(coupling_name) > 0;
 }

◆ have_parameter()

template<typename T >

bool InputParameters::have_parameter ( std::string_view name ) const

A wrapper around the Parameters base class method.

Checks for parameter rename before calling the base class method. This method tells whether a parameter with a known type is defined. If the type is unknown, use isParamDefined().

Parameters

name	The name to query the parameter values map with

Returns: Whether there is a key in the parameter values map corresponding to the (possibly renamed) name

Definition at line 2230 of file InputParameters.h.

 {
   const auto name = checkForRename(std::string(name_in));
 
   return Parameters::have_parameter<T>(name);
 }

◆ ignoreParameter()

template<typename T >

void InputParameters::ignoreParameter ( const std::string & name )

Informs this object that values for this parameter set from the input file or from the command line should be ignored.

Definition at line 1958 of file InputParameters.h.

Referenced by AddElementalFieldAction::validParams().

 {
   const auto name = checkForRename(name_in);
   suppressParameter<T>(name);
   _params[name]._ignore = true;
 }

◆ inputLocation()

std::string InputParameters::inputLocation ( const std::string & param ) const

Returns: A string representing the location in the input text the parameter originated from (i.e. filename,linenum) for the given param

Definition at line 1531 of file InputParameters.C.

Referenced by checkParams(), errorPrefix(), and MooseBaseParameterInterface::paramErrorMsg().

 {
   if (const auto hit_node = getHitNode(param))
     return hit_node->fileLocation(/* with_column = */ false);
   return "";
 }

◆ isCommandLineParameter()

bool InputParameters::isCommandLineParameter ( const std::string & name ) const

Returns: Whether or not the parameter name is a command line parameter

Definition at line 973 of file InputParameters.C.

 {
   return at(checkForRename(name))._cl_data.has_value();
 }

◆ isControllable()

bool InputParameters::isControllable ( const std::string & name ) const

Returns a Boolean indicating whether the specified parameter is controllable.

Definition at line 474 of file InputParameters.C.

Referenced by transferParam().

 {
   const auto name = checkForRename(name_in);
   return _params.count(name) > 0 && _params.at(name)._controllable;
 }

◆ isFinalized()

bool InputParameters::isFinalized ( ) const

inline

Returns: Whether or not finalize() has been called

Definition at line 1208 of file InputParameters.h.

Referenced by finalize(), and MooseBaseParameterInterface::MooseBaseParameterInterface().

1208 { return _finalized; }

InputParameters::_finalized

bool _finalized

Whether or not we've called finalize() on these parameters yet.

Definition: InputParameters.h:1409

◆ isFunctorNameType()

template<typename T >

constexpr bool InputParameters::isFunctorNameType ( )

staticprivate

Definition at line 2395 of file InputParameters.h.

 {
   return Moose::internal::isFunctorNameTypeHelper(Moose::internal::getNullptrExample<T>());
 }

◆ isParamDefined()

bool InputParameters::isParamDefined ( const std::string & name ) const

Method returns true if the parameter is defined for any type.

If the type is known, use have_parameter<T>() instead.

Parameters

name	The parameter name

Definition at line 1195 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   return _params.count(name) > 0;
 }

◆ isParamDeprecated()

bool InputParameters::isParamDeprecated ( const std::string & name ) const

Returns True if the parameters is deprecated.

Definition at line 429 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   return _params.count(name) > 0 && !_params.at(name)._deprecation_message.empty();
 }

◆ isParamRequired()

bool InputParameters::isParamRequired ( const std::string & name ) const

Returns a boolean indicating whether the specified parameter is required or not.

Definition at line 374 of file InputParameters.C.

Referenced by areAllRequiredParamsValid(), checkParams(), MooseServer::getCompletionItemKind(), and transferParam().

 {
   const auto name = checkForRename(name_in);
   return _params.count(name) > 0 && _params.at(name)._required;
 }

◆ isParamSetByAddParam()

bool InputParameters::isParamSetByAddParam ( const std::string & name ) const

Returns whether or not the parameter was set due to addParam.

If not then it was either set programmatically or was read through the input file.

Definition at line 422 of file InputParameters.C.

Referenced by MultiApp::createApp(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), hasDefault(), and TransientBase::TransientBase().

 {
   const auto name = checkForRename(name_in);
   return _params.count(name) > 0 && _params.at(name)._set_by_add_param;
 }

◆ isParamSetByUser()

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

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

Parameters

name	The parameter name

Definition at line 1178 of file InputParameters.C.

Referenced by CreateProblemAction::act(), SplitMeshAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), FEProblemBase::addOutput(), SystemBase::addVariable(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), Console::Console(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), AddVariableAction::init(), Console::initialSetup(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseBaseParameterInterface::isParamSetByUser(), MooseApp::isParamSetByUser(), MultiApp::keepSolutionDuringRestore(), LayeredBase::LayeredBase(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MultiApp::MultiApp(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::NearestPointBase(), paramSetByUser(), MooseMesh::prepare(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MooseMesh::setCoordSystem(), TransientBase::setupTimeIntegrator(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), vectorFunctionDim(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

 {
   const auto name = checkForRename(name_in);
   // Invalid; for sure not set by the user
   if (!isParamValid(name))
     return false;
   // Parameter is not located in the list (called Parameters::set)
   if (!_params.count(name))
     return false;
   // Special case for a command line option, which is a private parameter
   if (const auto cl_data = queryCommandLineMetadata(name))
     return cl_data->set_by_command_line;
   // Not a command line option, not set by addParam and not private
   return !_params.at(name)._set_by_add_param && !_params.at(name)._is_private;
 }

◆ isParamValid()

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

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

The value was supplied as a default argument or read and properly converted from the input file

Definition at line 390 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   if (have_parameter<MooseEnum>(name))
     return get<MooseEnum>(name).isValid();
   else if (have_parameter<std::vector<MooseEnum>>(name))
   {
     for (auto it = get<std::vector<MooseEnum>>(name).begin();
          it != get<std::vector<MooseEnum>>(name).end();
          ++it)
       if (!it->isValid())
         return false;
     return true;
   }
   else if (have_parameter<MultiMooseEnum>(name))
     return get<MultiMooseEnum>(name).isValid();
   else if (have_parameter<std::vector<MultiMooseEnum>>(name))
   {
     for (auto it = get<std::vector<MultiMooseEnum>>(name).begin();
          it != get<std::vector<MultiMooseEnum>>(name).end();
          ++it)
       if (!it->isValid())
         return false;
     return true;
   }
   else if (have_parameter<ExecFlagEnum>(name))
     return get<ExecFlagEnum>(name).isValid();
   else
     return _params.count(name) > 0 && _params.at(name)._valid;
 }

◆ isPrivate()

bool InputParameters::isPrivate ( const std::string & name ) const

Returns a Boolean indicating whether the specified parameter is private or not.

Definition at line 445 of file InputParameters.C.

Referenced by applyParameter(), checkParams(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), DumpObjectsProblem::stringifyParameters(), and transferParam().

 {
   const auto name = checkForRename(name_in);
   return _params.count(name) > 0 && _params.at(name)._is_private;
 }

◆ isRangeChecked()

bool InputParameters::isRangeChecked ( const std::string & param_name ) const

Return whether a parameter has a range check.

Definition at line 760 of file InputParameters.C.

Referenced by transferParam().

 {
   const auto name = checkForRename(param_name);
   return !_params.find(name)->second._range_function.empty();
 }

◆ isType()

template<typename T >

bool InputParameters::isType ( const std::string & name ) const

Returns: True if the parameter with name name is of type T.

Definition at line 2210 of file InputParameters.h.

Referenced by BatchMeshGeneratorAction::checkInputParameterType(), PostprocessorInterface::checkParam(), PostprocessorInterface::coupledPostprocessors(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), PostprocessorInterface::getPostprocessorNameInternal(), ReporterInterface::getReporterName(), and Reporter::getReporterValueName().

 {
   const auto name = checkForRename(name_in);
 
   if (!_params.count(name))
     mooseError("Parameter \"", name, "\" is not valid.");
   return have_parameter<T>(name);
 }

◆ makeParamNotRequired() [1/2]

template<typename T >

void InputParameters::makeParamNotRequired ( const std::string & name )

Changes the parameter to not be required.

Parameters

name	The parameter name

Definition at line 1979 of file InputParameters.h.

Referenced by MooseServer::getObjectParameters(), ExtraIDIntegralVectorPostprocessor::validParams(), and MortarConstraintBase::validParams().

 {
   const auto name = checkForRename(name_in);
 
   if (!this->have_parameter<T>(name))
     mooseError("Unable to un-require nonexistent parameter: ", name);
 
   _params[name]._required = false;
 }

◆ makeParamNotRequired() [2/2]

void InputParameters::makeParamNotRequired ( const std::string & name )

Forces parameter of given name to be not required regardless of type.

Definition at line 381 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
 
   if (_params.count(name))
     _params[name]._required = false;
 }

◆ makeParamRequired()

template<typename T >

void InputParameters::makeParamRequired ( const std::string & name )

Changes the parameter to be required.

Parameters

name	The parameter name

Definition at line 1967 of file InputParameters.h.

Referenced by SideSetsBetweenSubdomainsGenerator::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), and SideSetsAroundSubdomainGenerator::validParams().

 {
   const auto name = checkForRename(name_in);
 
   if (!this->have_parameter<T>(name))
     mooseError("Unable to require nonexistent parameter: ", name);
 
   _params[name]._required = true;
 }

◆ markControlled()

void InputParameters::markControlled ( const std::string & name )

Marker a parameter that has been changed by the Control system (this is for output purposes)

◆ mooseObjectSyntaxVisibility() [1/2]

void InputParameters::mooseObjectSyntaxVisibility ( bool visibility )

Mutators for controlling whether or not the outermost level of syntax will be collapsed when printed.

Definition at line 561 of file InputParameters.C.

Referenced by Moose::Builder::buildFullTree(), and Moose::Builder::buildJsonSyntaxTree().

 {
   _moose_object_syntax_visibility = visibility;
 }

◆ mooseObjectSyntaxVisibility() [2/2]

bool InputParameters::mooseObjectSyntaxVisibility ( ) const

Definition at line 567 of file InputParameters.C.

 {
   return _moose_object_syntax_visibility;
 }

◆ numberDefaultCoupledValues()

unsigned int InputParameters::numberDefaultCoupledValues ( const std::string & coupling_name ) const

Get the number of defaulted coupled value entries.

Parameters

coupling_name The name of the coupling parameter to get the default value for.

Definition at line 828 of file InputParameters.C.

Referenced by applyCoupledVar(), Coupleable::Coupleable(), Coupleable::coupledComponents(), Coupleable::getADDefaultVectorValue(), Coupleable::getDefaultArrayValue(), Coupleable::getDefaultValue(), and transferParam().

 {
   auto value_it = _params.find(coupling_name);
   if (value_it == _params.end())
     mooseError("Attempted to retrieve default value for coupled variable '",
                coupling_name,
                "' when none was provided.");
   return value_it->second._coupled_default.size();
 }

◆ operator+=()

InputParameters & InputParameters::operator+= ( const InputParameters & rhs )

Definition at line 184 of file InputParameters.C.

 {
   Parameters::operator+=(rhs);
 
   // TODO: this is not a proper merge - if a particular parameter exists in both this and rhs,
   // then we should actually smartly merge both metadata structs before storing in this.
   for (auto it = rhs._params.begin(); it != rhs._params.end(); ++it)
     _params[it->first] = it->second;
 
   _buildable_types.insert(
       _buildable_types.end(), rhs._buildable_types.begin(), rhs._buildable_types.end());
   _buildable_rm_types.insert(
       _buildable_rm_types.end(), rhs._buildable_rm_types.begin(), rhs._buildable_rm_types.end());
 
   // Collapse nesting and moose object syntax hiding are not modified with +=
   _coupled_vars.insert(rhs._coupled_vars.begin(), rhs._coupled_vars.end());
   _new_to_deprecated_coupled_vars.insert(rhs._new_to_deprecated_coupled_vars.begin(),
                                          rhs._new_to_deprecated_coupled_vars.end());
 
   _old_to_new_name_and_dep.insert(rhs._old_to_new_name_and_dep.begin(),
                                   rhs._old_to_new_name_and_dep.end());
   _new_to_old_names.insert(rhs._new_to_old_names.begin(), rhs._new_to_old_names.end());
   return *this;
 }

◆ operator=()

InputParameters & InputParameters::operator= ( const InputParameters & rhs )

Definition at line 145 of file InputParameters.C.

 {
   // An error to help minimize the segmentation faults that occure when MooseObjects do not have the
   // correct constructor
   if (!rhs._allow_copy)
   {
     const std::string & name =
         rhs.get<std::string>("_object_name"); // If _allow_parameter_copy is set then so is name
                                               // (see InputParameterWarehouse::addInputParameters)
     mooseError("Copying of the InputParameters object for the ",
                name,
                " object is not allowed.\n\nThe likely cause for this error ",
                "is having a constructor that does not use a const reference, all constructors\nfor "
                "MooseObject based classes should be as follows:\n\n",
                "    MyObject::MyObject(const InputParameters & parameters);");
   }
 
   Parameters::operator=(rhs);
 
   _params = rhs._params;
 
   _buildable_types = rhs._buildable_types;
   _buildable_rm_types = rhs._buildable_rm_types;
   _collapse_nesting = rhs._collapse_nesting;
   _moose_object_syntax_visibility = rhs._moose_object_syntax_visibility;
   _coupled_vars = rhs._coupled_vars;
   _new_to_deprecated_coupled_vars = rhs._new_to_deprecated_coupled_vars;
   _allow_copy = rhs._allow_copy;
   _block_fullpath = rhs._block_fullpath;
   _block_location = rhs._block_location;
   _old_to_new_name_and_dep = rhs._old_to_new_name_and_dep;
   _new_to_old_names = rhs._new_to_old_names;
   _hit_node = rhs._hit_node;
   _finalized = false;
 
   return *this;
 }

◆ paramAliases()

std::vector< std::string > InputParameters::paramAliases ( const std::string & param_name ) const

Return all the aliased names associated with param_name.

The returned container will always contain param_name itself. Other aliases in addition to param_name will include the base class parameter name if param_name is the derived class parameter name, or deprecated names that param_name is meant to replace.

Parameters

param_name The name of the parameter that we want to lookup aliases for. This parameter name must exist in our metadata and parameter names to values map, e.g. this parameter must represent the derived class parameter name if a base class parameter has been renamed or the blessed parameter name in situations where associated parameter names have been deprecated

Returns: All aliases which logically resolve-to/are-associated-with param_name, including param_name itself

Definition at line 1735 of file InputParameters.C.

 {
   mooseAssert(_values.find(param_name) != _values.end(),
               "The parameter we are searching for aliases for should exist in our parameter map");
   std::vector<std::string> aliases = {param_name};
 
   for (const auto & pr : as_range(_new_to_old_names.equal_range(param_name)))
     aliases.push_back(pr.second);
 
   return aliases;
 }

◆ paramFullpath()

std::string InputParameters::paramFullpath ( const std::string & param ) const

Returns: A string representing the full HIT parameter path from the input file (e.g. "Mesh/foo/bar" for param "bar") for the given param.

Definition at line 1539 of file InputParameters.C.

Referenced by checkParams(), and errorPrefix().

 {
   if (const auto hit_node = getHitNode(param))
     return hit_node->fullpath();
   return "";
 }

◆ paramSetByUser()

bool InputParameters::paramSetByUser ( const std::string & name ) const

Deprecated method.

Use isParamSetByUser() instead.

Definition at line 1171 of file InputParameters.C.

 {
   mooseDeprecated("paramSetByUser() is deprecated. Use isParamSetByUser() instead.");
   return isParamSetByUser(name);
 }

◆ queryCommandLineMetadata()

std::optional< InputParameters::CommandLineMetadata > InputParameters::queryCommandLineMetadata ( const std::string & name ) const

Returns: Queries for the command line metadata for the parameter name

Will return an empty optional if the parameter is not a command line param.

Definition at line 979 of file InputParameters.C.

Referenced by isParamSetByUser().

 {
   const auto & cl_data = at(checkForRename(name))._cl_data;
   if (!cl_data)
     return {};
   return *cl_data;
 }

◆ queryDataFileNamePath()

std::optional< Moose::DataFileUtils::Path > InputParameters::queryDataFileNamePath ( const std::string & name ) const

Returns: The DataFileName path for the parameter name (if any).

Definition at line 1748 of file InputParameters.C.

 {
   return at(checkForRename(name))._data_file_name_path;
 }

◆ rangeCheck() [1/2]

template<typename T , typename UP_T >

void InputParameters::rangeCheck	(	const std::string &	full_name,
		const std::string &	short_name,
		InputParameters::Parameter< T > *	param,
		std::ostream &	oss = `Moose::out`
	)

Runs a range on the supplied parameter if it exists and throws an error if that check fails.

Returns: Boolean indicating whether range check exists

Definition at line 1570 of file InputParameters.h.

Referenced by Moose::Builder::setScalarValueTypeParameter().

 {
   mooseAssert(param, "Parameter is NULL");
 
   if (!isParamValid(short_name) || _params[short_name]._range_function.empty())
     return;
 
   // Parse the expression
   FunctionParserBase<UP_T> fp;
   if (fp.Parse(_params[short_name]._range_function, short_name) != -1) // -1 for success
   {
     oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
     return;
   }
 
   // ensure range-checked input file parameter comparison functions
   // do absolute floating point comparisons instead of using a default epsilon.
   auto tmp_eps = fp.epsilon();
   fp.setEpsilon(0);
   // We require a non-const value for the implicit upscaling of the parameter type
   std::vector<UP_T> value(1, param->set());
   UP_T result = fp.Eval(&value[0]);
   fp.setEpsilon(tmp_eps);
 
   if (fp.EvalError())
   {
     oss << "Error evaluating expression: " << _params[short_name]._range_function
         << "\nPerhaps you used the wrong variable name?\n";
     return;
   }
 
   if (!result)
     oss << "Range check failed for parameter " << full_name
         << "\n\tExpression: " << _params[short_name]._range_function << "\n\tValue: " << value[0]
         << '\n';
 }

◆ rangeCheck() [2/2]

template<typename T , typename UP_T >

void InputParameters::rangeCheck	(	const std::string &	full_name,
		const std::string &	short_name,
		InputParameters::Parameter< std::vector< T >> *	param,
		std::ostream &	oss = `Moose::out`
	)

Automatically detect the variables used in the range checking expression. We allow the following variables (where snam is the short_name of the parameter)

snam : tests every component in the vector 'snam > 0' snam_size : the size of the vector 'snam_size = 5' snam_i : where i is a number from 0 to sname_size-1 tests a specific component 'snam_0 > snam_1'

Definition at line 1457 of file InputParameters.h.

 {
   mooseAssert(param, "Parameter is NULL");
 
   if (!isParamValid(short_name) || _params[short_name]._range_function.empty())
     return;
 
   FunctionParserBase<UP_T> fp;
   std::vector<std::string> vars;
   if (fp.ParseAndDeduceVariables(_params[short_name]._range_function, vars) != -1) // -1 for success
   {
     oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
     return;
   }
 
   // Fparser parameter buffer
   std::vector<UP_T> parbuf(vars.size());
 
   // parameter vector
   const std::vector<T> & value = param->set();
 
   // iterate over all vector values (maybe ;)
   bool need_to_iterate = false;
   unsigned int i = 0;
   do
   {
     // set parameters
     for (unsigned int j = 0; j < vars.size(); j++)
     {
       if (vars[j] == short_name)
       {
         if (value.size() == 0)
         {
           oss << "Range checking empty vector: " << _params[short_name]._range_function << '\n';
           return;
         }
 
         parbuf[j] = value[i];
         need_to_iterate = true;
       }
       else if (vars[j] == short_name + "_size")
         parbuf[j] = value.size();
       else
       {
         if (vars[j].substr(0, short_name.size() + 1) != short_name + "_")
         {
           oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
           return;
         }
         std::istringstream iss(vars[j]);
         iss.seekg(short_name.size() + 1);
 
         size_t index;
         if (iss >> index && iss.eof())
         {
           if (index >= value.size())
           {
             oss << "Error parsing expression: " << _params[short_name]._range_function
                 << "\nOut of range variable " << vars[j] << '\n';
             return;
           }
           parbuf[j] = value[index];
         }
         else
         {
           oss << "Error parsing expression: " << _params[short_name]._range_function
               << "\nInvalid variable " << vars[j] << '\n';
           return;
         }
       }
     }
 
     // ensure range-checked input file parameter comparison functions
     // do absolute floating point comparisons instead of using a default epsilon.
     auto tmp_eps = fp.epsilon();
     fp.setEpsilon(0);
     UP_T result = fp.Eval(&parbuf[0]);
     fp.setEpsilon(tmp_eps);
 
     // test function using the parameters determined above
     if (fp.EvalError())
     {
       oss << "Error evaluating expression: " << _params[short_name]._range_function << '\n';
       return;
     }
 
     if (!result)
     {
       oss << "Range check failed for parameter " << full_name
           << "\n\tExpression: " << _params[short_name]._range_function << "\n";
       if (need_to_iterate)
         oss << "\t Component: " << i << '\n';
     }
 
   } while (need_to_iterate && ++i < value.size());
 }

◆ rangeCheckedFunction()

std::string InputParameters::rangeCheckedFunction ( const std::string & name ) const

Return the range check function for any parameter (empty string if it is not range checked)

Definition at line 767 of file InputParameters.C.

Referenced by transferParam().

 {
   const auto name = checkForRename(param_name);
   return _params.at(name)._range_function;
 }

◆ rawParamVal()

std::string InputParameters::rawParamVal ( const std::string & param ) const

Returns: A string representing the raw, unmodified token text for the given param. This is only set if this parameter is parsed from hit

Definition at line 1603 of file InputParameters.C.

 {
   if (const auto hit_node = getHitNode(param))
     return hit_node->strVal();
   return "";
 }

◆ registerBase()

void InputParameters::registerBase ( const std::string & value )

This method must be called from every base "Moose System" to create linkage with the Action System.

See "Moose.C" for the registerMooseObjectTask() calls.

Definition at line 488 of file InputParameters.C.

 {
   InputParameters::set<std::string>("_moose_base") = value;
   _params["_moose_base"]._is_private = true;
 }

◆ registerBuildableTypes()

void InputParameters::registerBuildableTypes ( const std::string & names )

This method is here to indicate which Moose types a particular Action may build.

It takes a space delimited list of registered MooseObjects. TODO: For now we aren't actually checking this list when we build objects. Since individual actions can do whatever they want it's not exactly trivial to check this without changing the user API. This function properly restricts the syntax and YAML dumps.

Definition at line 519 of file InputParameters.C.

 {
   _buildable_types.clear();
   MooseUtils::tokenize(names, _buildable_types, 1, " \t\n\v\f\r"); // tokenize on whitespace
 }

◆ registerSystemAttributeName()

void InputParameters::registerSystemAttributeName ( const std::string & value )

This method is used to define the MOOSE system name that is used by the TheWarehouse object for storing objects to be retrieved for execution.

The base class of every object class that will be called for execution (e.g., UserObject objects) should call this method.

This is different from registerBase because the name supplied to registerBase is used to associate syntax, but the objects created often go to the same objects for execution, as is the case for Postprocessor object which are executed with UserObjects.

See the AttribSystem object for use Attribute.h/C.

Definition at line 503 of file InputParameters.C.

Referenced by Distribution::validParams(), LinearFVFluxKernel::validParams(), ScalarKernelBase::validParams(), Constraint::validParams(), LinearFVElementalKernel::validParams(), FVDirichletBCBase::validParams(), TimeStepper::validParams(), Split::validParams(), Damper::validParams(), FVElementalKernel::validParams(), FVFluxBC::validParams(), InterfaceKernelBase::validParams(), DiracKernelBase::validParams(), BoundaryCondition::validParams(), NodalKernelBase::validParams(), FVFluxKernel::validParams(), DGKernelBase::validParams(), UserObject::validParams(), Sampler::validParams(), LinearFVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), and AuxKernelTempl< Real >::validParams().

 {
   InputParameters::set<std::string>("_moose_warehouse_system_name") = value;
   _params["_moose_warehouse_system_name"]._is_private = true;
 }

◆ renameCoupledVar()

void InputParameters::renameCoupledVar	(	const std::string &	old_name,
		const std::string &	new_name,
		const std::string &	new_docstring
	)

Rename a coupled variable and provide a new documentation string.

Parameters

old_name	The old name of the coupled variable
new_name	The new name of the coupled variable
new_docstring	The new documentation string for the coupled variable

Definition at line 1702 of file InputParameters.C.

Referenced by ADPenaltyPeriodicSegmentalConstraint::validParams(), ADPeriodicSegmentalConstraint::validParams(), PeriodicSegmentalConstraint::validParams(), PenaltyPeriodicSegmentalConstraint::validParams(), and ScalarLMKernelTempl< is_ad >::validParams().

 {
   renameCoupledVarInternal(old_name, new_name, new_docstring, "");
 }

◆ renameCoupledVarInternal()

void InputParameters::renameCoupledVarInternal	(	const std::string &	old_name,
		const std::string &	new_name,
		const std::string &	docstring,
		const std::string &	removal_date
	)

private

Definition at line 1676 of file InputParameters.C.

Referenced by deprecateCoupledVar(), and renameCoupledVar().

 {
   auto coupled_vars_it = _coupled_vars.find(old_name);
   if (coupled_vars_it == _coupled_vars.end())
     mooseError("Requested to rename coupled variable '",
                old_name,
                "' but that coupled variable name doesn't exist in the parameters object.");
 
   _coupled_vars.insert(new_name);
   _coupled_vars.erase(coupled_vars_it);
 
   renameParamInternal(old_name, new_name, docstring, removal_date);
 }

◆ renameParam()

void InputParameters::renameParam	(	const std::string &	old_name,
		const std::string &	new_name,
		const std::string &	new_docstring
	)

Rename a parameter and provide a new documentation string.

Parameters

old_name	The old name of the parameter
new_name	The new name of the parameter
new_docstring	The new documentation string for the parameter If left empty, uses the old docstring for the renamed parameter

Definition at line 1694 of file InputParameters.C.

Referenced by ParsedSubdomainMeshGenerator::validParams(), SideSetsBetweenSubdomainsGenerator::validParams(), SidesetAroundSubdomainUpdater::validParams(), MultiAppGeneralFieldNearestLocationTransfer::validParams(), and SideSetsAroundSubdomainGenerator::validParams().

 {
   renameParamInternal(old_name, new_name, new_docstring, "");
 }

◆ renameParameterGroup()

void InputParameters::renameParameterGroup	(	const std::string &	old_name,
		const std::string &	new_name
	)

This method renames a parameter group.

Parameters

old_name	previous name of the parameter group
new_name	new name of the parameter group

Definition at line 954 of file InputParameters.C.

 {
   for (auto & param : _params)
     if (param.second._group == old_name)
       param.second._group = new_name;
 }

◆ renameParamInternal()

void InputParameters::renameParamInternal	(	const std::string &	old_name,
		const std::string &	new_name,
		const std::string &	docstring,
		const std::string &	removal_date
	)

private

Definition at line 1642 of file InputParameters.C.

Referenced by deprecateParam(), renameCoupledVarInternal(), and renameParam().

 {
   auto params_it = _params.find(old_name);
   if (params_it == _params.end())
     mooseError("Requested to rename parameter '",
                old_name,
                "' but that parameter name doesn't exist in the parameters object.");
   mooseAssert(params_it->second._deprecation_message.empty(),
               "Attempting to rename the parameter, '" << old_name << "', that is deprecated");
 
   auto new_metadata = std::move(params_it->second);
   if (!docstring.empty())
     new_metadata._doc_string = docstring;
   _params.emplace(new_name, std::move(new_metadata));
   _params.erase(params_it);
 
   auto values_it = _values.find(old_name);
   auto new_value = std::move(values_it->second);
   _values.emplace(new_name, std::move(new_value));
   _values.erase(values_it);
 
   std::string deprecation_message;
   if (!removal_date.empty())
     deprecation_message = "'" + old_name + "' has been deprecated and will be removed on " +
                           removal_date + ". Please use '" + new_name + "' instead.";
 
   _old_to_new_name_and_dep.emplace(old_name, std::make_pair(new_name, deprecation_message));
   _new_to_old_names.emplace(new_name, old_name);
 }

◆ reservedValues()

std::set< std::string > InputParameters::reservedValues ( const std::string & name ) const

Get a set of reserved parameter values.

Returns a set by value since we can return an empty set.

Definition at line 1490 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   auto it = _params.find(name);
   if (it == _params.end())
     return std::set<std::string>();
   return it->second._reserved_values;
 }

◆ set()

template<typename T >

T & InputParameters::set	(	const std::string &	name,
		bool	quiet_mode = `false`
	)

Returns a writable reference to the named parameters.

Note: This is not a virtual function! Use caution when comparing to the parent class implementation

Parameters

name	The name of the parameter to set
quiet_mode	When true the parameter is kept with set_by_add_param=true, this is generally not needed.

"quite_mode" returns a writable reference to the named parameter, without setting set_by_add_param to false. Using this method of set will make the parameter to continue to behave if its value where set ONLY by addParam and not by any other method.

This was added for handling parameters in the Output objects that have behavior dependent on whether the user modified the parameters.

Definition at line 1428 of file InputParameters.h.

 {
   const auto name = checkForRename(name_in);
 
   checkParamName(name);
   checkConsistentType<T>(name);
 
   T & result = this->Parameters::set<T>(name);
 
   if (quiet_mode)
     _params[name]._set_by_add_param = true;
 
   setHelper<T>(name);
 
   return result;
 }

◆ set_attributes()

void InputParameters::set_attributes	(	const std::string &	name,
		bool	inserted_only
	)

overridevirtual

Override from libMesh to set user-defined attributes on our parameter.

"._set_by_add_param" and ".deprecated_params" are not populated until after the default value has already been set in libMesh (first callback to this method). Therefore if a variable is in/not in one of these sets, you can be assured it was put there outside of the "addParam*()" calls.

Reimplemented from libMesh::Parameters.

Definition at line 88 of file InputParameters.C.

Referenced by applyParameter().

 {
   const auto name = checkForRename(name_in);
 
   if (!inserted_only)
   {
     auto & metadata = _params[name];
     metadata._set_by_add_param = false;
 
     // valid_params don't make sense for MooseEnums
     if (!have_parameter<MooseEnum>(name) && !have_parameter<MultiMooseEnum>(name))
       metadata._valid = true;
   }
 }

◆ setDeprecatedVarDocString()

void InputParameters::setDeprecatedVarDocString	(	const std::string &	new_name,
		const std::string &	doc_string
	)

private

Private method for setting deprecated coupled variable documentation strings.

Definition at line 210 of file InputParameters.C.

Referenced by addCoupledVar().

 {
   auto coupled_vars_it = _new_to_deprecated_coupled_vars.find(new_name);
   if (coupled_vars_it != _new_to_deprecated_coupled_vars.end())
   {
     auto params_it = _params.find(coupled_vars_it->second);
     if (params_it == _params.end())
       mooseError("There must have been a mistake in the construction of the new to deprecated "
                  "coupled vars map because the old name ",
                  coupled_vars_it->second,
                  " doesn't exist in the parameters data.");
 
     params_it->second._doc_string = doc_string;
   }
 }

◆ setDocString()

void InputParameters::setDocString	(	const std::string &	name,
		const std::string &	doc
	)

Set the doc string of a parameter.

This method is generally used from within the validParams function to modify the documentation for an existing parameter, such as a parameter that is supplied from an interface class.

Definition at line 347 of file InputParameters.C.

Referenced by TableOutput::addMultiAppFixedPointIterationEndExecFlag(), Moose::SlepcSupport::getSlepcValidParams(), PropertyReadFile::validParams(), FVIntegralValueConstraint::validParams(), FVBoundedValueConstraint::validParams(), FVPointValueConstraint::validParams(), MultiAppTransfer::validParams(), MortarConstraintBase::validParams(), Output::validParams(), AuxKernelTempl< Real >::validParams(), and MultiApp::validParams().

 {
   const auto name = checkForRename(name_in);
 
   auto it = _params.find(name);
   if (it == _params.end())
     mooseError("Unable to set the documentation string (using setDocString) for the \"",
                name,
                "\" parameter, the parameter does not exist.");
   it->second._doc_string = doc;
 }

◆ setDocUnit()

void InputParameters::setDocUnit	(	const std::string &	name,
		const std::string &	doc_unit
	)

Set the unit string of a parameter.

This method is only used within MooseDocs and the input syntax dump in order to provide a developer-expected unit for software quality assurance purposes.

Definition at line 367 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   _params[name]._doc_unit = doc_unit;
 }

◆ setGlobalCommandLineParam()

void InputParameters::setGlobalCommandLineParam ( const std::string & name )

Sets the command line parameter with name as global.

Global here means that it will be passed to all child MultiApps.

Definition at line 962 of file InputParameters.C.

Referenced by MooseApp::validParams().

 {
   auto & cl_data = at(checkForRename(name))._cl_data;
   if (!cl_data)
     mooseError("InputParameters::setGlobalCommandLineParam: The parameter '",
                name,
                "' is not a command line parameter");
   cl_data->global = true;
 }

◆ setHelper()

template<typename T >

void InputParameters::setHelper ( const std::string & name )

This functions is called in set as a 'callback' to avoid code duplication.

Definition at line 1421 of file InputParameters.h.

1422 {

1423 }

◆ setHitNode() [1/2]

void InputParameters::setHitNode	(	const std::string &	param,
		const hit::Node &	node,
		const SetParamHitNodeKey
	)

Sets the hit node associated with the parameter param to node.

Is protected to be called by only the Builder via the SetParamHitNodeKey.

Definition at line 1522 of file InputParameters.C.

Referenced by FEProblemBase::addAnyRedistributers(), applyParameters(), Action::associateWithParameter(), Factory::clone(), ActionFactory::create(), Factory::initialize(), and Moose::Builder::walkRaw().

 {
   mooseAssert(node.type() == hit::NodeType::Field, "Must be a field");
   at(param)._hit_node = &node;
 }

◆ setHitNode() [2/2]

void InputParameters::setHitNode	(	const hit::Node &	node,
		const SetHitNodeKey
	)

inline

Sets the hit node that represents the syntax responsible for creating these parameters.

Is protected to be called by only the ActionFactory, Builder, and Factory via the SetHitNodeKey.

Definition at line 1203 of file InputParameters.h.

1203 { _hit_node = &node; }

InputParameters::_hit_node

const hit::Node * _hit_node

The hit node representing the syntax that created these parameters, if any.

Definition: InputParameters.h:1406

◆ setParameters() [1/2]

template<typename T , typename... Ts>

void InputParameters::setParameters	(	const std::string &	name,
		const T &	value,
		Ts...	extra_input_parameters
	)

Given a series of parameters names and values, sets each name to the corresponding value.

Any number of name, value pairs can be supplied.

Note that each value must be of the correct type for the parameter of that name, not merely of a type convertible to the correct type.

Parameters

name	The name of the first parameter to set

Definition at line 1447 of file InputParameters.h.

Referenced by MeshGenerator::addMeshSubgenerator(), SideSetsFromNormalsGenerator::validParams(), SideSetsFromPointsGenerator::validParams(), and AllSideSetsByNormalsGenerator::validParams().

 {
   this->set<T>(name) = value;
   this->setParameters(extra_input_parameters...);
 }

◆ setParameters() [2/2]

void InputParameters::setParameters ( )

inlineprivate

Method to terminate the recursive setParameters definition.

Definition at line 1222 of file InputParameters.h.

Referenced by setParameters().

1222 {}

◆ setParamHelper() [1/17]

template<typename T , typename S >

void InputParameters::setParamHelper	(	const std::string &	name,
		T &	l_value,
		const S &	r_value
	)

private

This method is called when adding a Parameter with a default value, can be specialized for non-matching types.

Definition at line 1691 of file InputParameters.h.

Referenced by addParam().

 {
   l_value = r_value;
 }

◆ setParamHelper() [2/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		PostprocessorName &	l_value,
		const Real &	r_value
	)

private

Definition at line 1365 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [3/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		PostprocessorName &	l_value,
		const int &	r_value
	)

private

Definition at line 1377 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [4/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		FunctionName &	l_value,
		const Real &	r_value
	)

private

Definition at line 1389 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [5/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		FunctionName &	l_value,
		const int &	r_value
	)

private

Definition at line 1401 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [6/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MaterialPropertyName &	l_value,
		const Real &	r_value
	)

private

Definition at line 1413 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [7/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MaterialPropertyName &	l_value,
		const int &	r_value
	)

private

Definition at line 1425 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [8/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MooseFunctorName &	l_value,
		const Real &	r_value
	)

private

Definition at line 1437 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [9/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MooseFunctorName &	l_value,
		const int &	r_value
	)

private

Definition at line 1449 of file InputParameters.C.

 {
   // Assign the default value so that it appears in the dump
   std::ostringstream oss;
   oss << r_value;
   l_value = oss.str();
 }

◆ setParamHelper() [10/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	name,
		PostprocessorName &	l_value,
		const Real &	r_value
	)

private

◆ setParamHelper() [11/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	name,
		PostprocessorName &	l_value,
		const int &	r_value
	)

private

◆ setParamHelper() [12/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		FunctionName &	l_value,
		const Real &	r_value
	)

private

◆ setParamHelper() [13/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		FunctionName &	l_value,
		const int &	r_value
	)

private

◆ setParamHelper() [14/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MaterialPropertyName &	l_value,
		const Real &	r_value
	)

private

◆ setParamHelper() [15/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MaterialPropertyName &	l_value,
		const int &	r_value
	)

private

◆ setParamHelper() [16/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MooseFunctorName &	l_value,
		const Real &	r_value
	)

private

◆ setParamHelper() [17/17]

template<>

void InputParameters::setParamHelper	(	const std::string &	,
		MooseFunctorName &	l_value,
		const int &	r_value
	)

private

◆ setReservedValues()

void InputParameters::setReservedValues	(	const std::string &	name,
		const std::set< std::string > &	reserved
	)

Provide a set of reserved values for a parameter.

These are values that are in addition to the normal set of values the parameter can take.

Definition at line 1482 of file InputParameters.C.

Referenced by OutputInterface::validParams().

 {
   const auto name = checkForRename(name_in);
   _params[name]._reserved_values = reserved;
 }

◆ shouldIgnore()

bool InputParameters::shouldIgnore ( const std::string & name )

Whether to ignore the value of an input parameter set in the input file or from the command line.

Definition at line 1555 of file InputParameters.C.

 {
   const auto name = checkForRename(name_in);
   auto it = _params.find(name);
   if (it != _params.end())
     return it->second._ignore;
   mooseError("Parameter ", name, " does not exist");
 }

◆ suppressParameter()

template<typename T >

void InputParameters::suppressParameter ( const std::string & name )

This method suppresses an inherited parameter so that it isn't required or valid in the derived class.

The parameter is added to the private parameter list. Suppressing a parameter can have dire consequences. Use at your own risk!

Definition at line 1944 of file InputParameters.h.

Referenced by TimestepSize::validParams(), ExternalProblem::validParams(), DiscreteElementUserObject::validParams(), MooseObjectAction::validParams(), CSVReaderVectorPostprocessor::validParams(), MassMatrix::validParams(), SideSetsFromNormalsGenerator::validParams(), MooseStaticCondensationPreconditioner::validParams(), MultiAppCloneReporterTransfer::validParams(), PseudoTimestep::validParams(), AccumulateReporter::validParams(), Times::validParams(), SideSetsBetweenSubdomainsGenerator::validParams(), FVMassMatrix::validParams(), SideSetsFromPointsGenerator::validParams(), CentroidMultiApp::validParams(), QuadraturePointMultiApp::validParams(), DiffusionFV::validParams(), NumNonlinearIterations::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), ElementHDivSemiError::validParams(), MultiAppGeneralFieldShapeEvaluationTransfer::validParams(), ElementSubdomainModifierBase::validParams(), AllSideSetsByNormalsGenerator::validParams(), ElementHCurlSemiError::validParams(), NodePositions::validParams(), ParsedGenerateNodeset::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), CSV::validParams(), ReporterPointSource::validParams(), TagAuxBase< AuxKernel >::validParams(), SideSetsAroundSubdomainGenerator::validParams(), ParsedGenerateSideset::validParams(), MultiAppGeneralFieldNearestLocationTransfer::validParams(), MortarNodalAuxKernelTempl< ComputeValueType >::validParams(), FunctorExtremaPositions::validParams(), VariableResidualNormsDebugOutput::validParams(), Convergence::validParams(), ActionComponent::validParams(), NearestRadiusLayeredAverage::validParams(), MultiAppUserObjectTransfer::validParams(), MeshGenerator::validParams(), Function::validParams(), Executioner::validParams(), and Marker::validParams().

 {
   const auto name = checkForRename(name_in);
   if (!this->have_parameter<T>(name))
     mooseError("Unable to suppress nonexistent parameter: ", name);
 
   auto & metadata = _params[name];
   metadata._required = false;
   metadata._is_private = true;
   metadata._controllable = false;
 }

◆ transferParam()

template<typename T >

void InputParameters::transferParam	(	const InputParameters &	source_param,
		const std::string &	name,
		const std::string &	new_name = `""`,
		const std::string &	new_description = `""`
	)

A routine to transfer a parameter from one class' validParams to another.

Parameters

source_param	The parameters list holding the param we would like to transfer
name	The name of the parameter to transfer
new_description	A new description of the parameter. If unspecified, uses the source_params'

Definition at line 2239 of file InputParameters.h.

Referenced by DiffusionCG::validParams(), and MooseVariableBase::validParams().

 {
   const auto name = source_params.checkForRename(std::string(name_in));
   const auto p_name = new_name.empty() ? name_in : new_name;
   if (!source_params.have_parameter<T>(name) && !source_params.hasCoupledValue(name))
     mooseError("The '",
                name_in,
                "' parameter could not be transferred because it does not exist with type '",
                MooseUtils::prettyCppType<T>(),
                "' in the source parameters");
   if (name != name_in)
     mooseWarning("The transferred parameter " + name_in + " is deprecated in favor of " + name +
                  " in the source parameters. The new name should likely be used for the parameter "
                  "transfer instead.");
   const std::string description =
       new_description.empty() ? source_params.getDescription(name) : new_description;
 
   if (source_params.isParamRequired(name))
   {
     // Check for a variable parameter
     if (source_params.hasCoupledValue(name))
       addRequiredCoupledVar(p_name, description);
     // Enums parameters have a default list of options
     else if constexpr (std::is_same_v<MooseEnum, T> || std::is_same_v<MultiMooseEnum, T>)
       addRequiredParam<T>(p_name, source_params.get<T>(name), description);
     else if (source_params.isRangeChecked(name))
       addRequiredRangeCheckedParam<T>(
           p_name, source_params.rangeCheckedFunction(name), description);
     else
       addRequiredParam<T>(p_name, description);
   }
   else
   {
     // Check for a variable parameter
     if (source_params.hasCoupledValue(name))
     {
       if (!source_params.hasDefaultCoupledValue(name))
         addCoupledVar(p_name, description);
       else if (source_params.numberDefaultCoupledValues(name) == 1)
         addCoupledVar(p_name, source_params.defaultCoupledValue(name), description);
       else
       {
         std::vector<Real> coupled_values;
         for (const auto i : libMesh::make_range(source_params.numberDefaultCoupledValues(name)))
           coupled_values.push_back(source_params.defaultCoupledValue(name, i));
         addCoupledVar(p_name, coupled_values, description);
       }
     }
     else if (source_params.isRangeChecked(name))
     {
       if (source_params.hasDefault(name))
         addRangeCheckedParam<T>(p_name,
                                 source_params.get<T>(name),
                                 source_params.rangeCheckedFunction(name),
                                 description);
       else
         addRangeCheckedParam<T>(p_name, source_params.rangeCheckedFunction(name), description);
     }
     else if constexpr (std::is_same_v<MooseEnum, T> || std::is_same_v<MultiMooseEnum, T>)
       addParam<T>(p_name, source_params.get<T>(name), description);
     else
     {
       if (source_params.hasDefault(name))
         addParam<T>(p_name, source_params.get<T>(name), description);
       else
         addParam<T>(p_name, description);
     }
   }
 
   // Copy other attributes
   if (source_params.isPrivate(name))
     _params[p_name]._is_private = true;
   if (source_params.isControllable(name))
     _params[p_name]._controllable = true;
 }

◆ type()

std::string InputParameters::type ( const std::string & name ) const

Prints the type of the requested parameter by name.

Definition at line 851 of file InputParameters.C.

Referenced by MooseServer::addValuesToList(), BatchMeshGeneratorAction::checkInputParameterType(), PostprocessorInterface::checkParam(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseServer::getNodesByValueAndTypes(), ReporterInterface::getReporterName(), and Reporter::getReporterValueName().

 {
   const auto name = checkForRename(name_in);
   if (!_values.count(name))
     mooseError("Parameter \"", name, "\" not found.\n\n", *this);
 
   if (_coupled_vars.find(name) != _coupled_vars.end())
     return "std::vector<VariableName>";
   else if (_params.count(name) > 0 && !_params.at(name)._custom_type.empty())
     return _params.at(name)._custom_type;
   return _values.at(name)->type();
 }

◆ varName()

std::string InputParameters::varName	(	const std::string &	var_param_name,
		const std::string &	moose_object_with_var_param_name
	)		const

Determine the actual variable name from the given variable parameter name.

Parameters

var_param_name	the name of the variable parameter, e.g. 'variable'
moose_object_with_var_param_name	the name of the moose object holding the variable parameter. Used for potential error messaging

Definition at line 1611 of file InputParameters.C.

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addScalarKernel(), and MooseVariableInterface< Real >::MooseVariableInterface().

 {
   // Try the scalar version first
   std::string variable_name = getMooseType(var_param_name);
   if (variable_name == "")
   {
     auto vec = getVecMooseType(var_param_name);
 
     // Catch the (very unlikely) case where a user specifies
     // variable = '' (the empty string)
     // in their input file. This could happen if e.g. something goes
     // wrong with dollar bracket expression expansion.
     if (vec.empty())
       mooseError("Error constructing object '",
                  moose_object_with_var_param_name,
                  "' while retrieving value for '",
                  var_param_name,
                  "' parameter! Did you forget to set '",
                  var_param_name,
                  "' or set it to '' (empty string) by accident?");
 
     // When using vector variables, we are only going to use the first one in the list at the
     // interface level...
     variable_name = vec[0];
   }
 
   return variable_name;
 }

Friends And Related Function Documentation

◆ ActionWarehouse

friend class ActionWarehouse

friend

Definition at line 1416 of file InputParameters.h.

◆ emptyInputParameters

InputParameters emptyInputParameters ( )

friend

Definition at line 30 of file InputParameters.C.

 {
   InputParameters params;
   return params;
 }

◆ InputParameterWarehouse

friend class InputParameterWarehouse

friend

Definition at line 1413 of file InputParameters.h.

◆ Parser

friend class Parser

friend

Definition at line 1414 of file InputParameters.h.

Member Data Documentation

◆ _allow_copy

bool InputParameters::_allow_copy

private

A flag for toggling the error message in the copy constructor.

Definition at line 1390 of file InputParameters.h.

Referenced by allowCopy(), clear(), and operator=().

◆ _block_fullpath

std::string InputParameters::_block_fullpath

private

full HIT path of the block from the input file - used for nice error messages.

Definition at line 1352 of file InputParameters.h.

Referenced by clear(), and operator=().

◆ _block_location

std::string InputParameters::_block_location

private

original location of input block (i.e. filename,linenum) - used for nice error messages.

Definition at line 1349 of file InputParameters.h.

Referenced by clear(), and operator=().

◆ _buildable_rm_types

std::vector<std::tuple<std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback> > InputParameters::_buildable_rm_types

private

The RelationshipManagers that this object may either build or require.

The optional second argument may be supplied to "downgrade" the functionality of the corresponding relationship manager (e.g. An AlgebraicRelationshipManager could be only used as a GeometricRelationshipManager for a given simulation).

Definition at line 1376 of file InputParameters.h.

Referenced by addRelationshipManager(), clearRelationshipManagers(), getBuildableRelationshipManagerTypes(), operator+=(), and operator=().

◆ _buildable_types

std::vector<std::string> InputParameters::_buildable_types

private

The parameter is used to restrict types that can be built.

Typically this is used for MooseObjectAction derived Actions.

Definition at line 1367 of file InputParameters.h.

Referenced by getBuildableTypes(), operator+=(), operator=(), and registerBuildableTypes().

◆ _class_description

std::string InputParameters::_class_description

private

The class description for the owning object.

This string is used in many places including mouse-over events, and external documentation produced from the source code.

Definition at line 1363 of file InputParameters.h.

Referenced by addClassDescription(), and getClassDescription().

◆ _collapse_nesting

bool InputParameters::_collapse_nesting

private

This parameter collapses one level of nesting in the syntax blocks.

It is used in conjunction with MooseObjectAction derived Actions.

Definition at line 1380 of file InputParameters.h.

Referenced by clear(), collapseSyntaxNesting(), InputParameters(), and operator=().

◆ _coupled_vars

std::set<std::string> InputParameters::_coupled_vars

private

The coupled variables set.

Definition at line 1359 of file InputParameters.h.

Referenced by addCoupledVar(), addCoupledVarWithAutoBuild(), addDeprecatedCoupledVar(), addRequiredCoupledVar(), clear(), coupledVarsBegin(), coupledVarsEnd(), getCoupledVariableParamNames(), hasCoupledValue(), hasDefaultCoupledValue(), operator+=(), operator=(), renameCoupledVarInternal(), and type().

◆ _finalized

bool InputParameters::_finalized

private

Whether or not we've called finalize() on these parameters yet.

Definition at line 1409 of file InputParameters.h.

Referenced by clear(), finalize(), isFinalized(), and operator=().

◆ _hit_node

const hit::Node* InputParameters::_hit_node

private

The hit node representing the syntax that created these parameters, if any.

Definition at line 1406 of file InputParameters.h.

Referenced by clear(), getHitNode(), operator=(), and setHitNode().

◆ _moose_object_syntax_visibility

bool InputParameters::_moose_object_syntax_visibility

private

This parameter hides derived MOOSE object types from appearing in syntax dumps.

Definition at line 1383 of file InputParameters.h.

Referenced by clear(), InputParameters(), mooseObjectSyntaxVisibility(), and operator=().

◆ _new_to_deprecated_coupled_vars

std::unordered_map<std::string, std::string> InputParameters::_new_to_deprecated_coupled_vars

private

A map from deprecated coupled variable names to the new blessed name.

Definition at line 1393 of file InputParameters.h.

Referenced by addDeprecatedCoupledVar(), checkParams(), clear(), getNewToDeprecatedVarMap(), operator+=(), operator=(), and setDeprecatedVarDocString().

◆ _new_to_old_names

std::multimap<std::string, std::string> InputParameters::_new_to_old_names

private

A map from derived-class/blessed parameter names to associated base-class/deprecated parameter names.

Definition at line 1403 of file InputParameters.h.

Referenced by clear(), operator+=(), operator=(), paramAliases(), and renameParamInternal().

◆ _old_to_new_name_and_dep

std::map<std::string, std::pair<std::string, std::string> > InputParameters::_old_to_new_name_and_dep

private

A map from base-class/deprecated parameter names to derived-class/blessed parameter names and the deprecation messages in the case that the "old" parameter name is a deprecated parameter name.

The deprecation message will be empty if the "old" parameter name represents a base class parameter name

Definition at line 1399 of file InputParameters.h.

Referenced by addDeprecatedParam(), attemptPrintDeprecated(), checkForRename(), clear(), operator+=(), operator=(), and renameParamInternal().

◆ _params

std::map<std::string, Metadata> InputParameters::_params

private

The actual parameter data.

Each Metadata object contains attributes for the corresponding parameter.

Definition at line 1356 of file InputParameters.h.

Referenced by addCoupledVar(), addCoupledVarWithAutoBuild(), addCustomTypeParam(), addDeprecatedCoupledVar(), addDeprecatedCustomTypeParam(), addDeprecatedParam(), addParam(), addParamNamesToGroup(), addPrivateParam(), addRangeCheckedParam(), addRequiredCustomTypeParam(), addRequiredParam(), addRequiredRangeCheckedParam(), applyParameter(), at(), attemptPrintDeprecated(), clear(), declareControllable(), defaultCoupledValue(), getAutoBuildVectors(), getControllableParameters(), getDescription(), getDocString(), getDocUnit(), getGroupName(), getGroupParameters(), getParametersList(), hasDefaultCoupledValue(), ignoreParameter(), InputParameters(), isControllable(), isParamDefined(), isParamDeprecated(), isParamRequired(), isParamSetByAddParam(), isParamSetByUser(), isParamValid(), isPrivate(), isRangeChecked(), isType(), makeParamNotRequired(), makeParamRequired(), numberDefaultCoupledValues(), operator+=(), operator=(), rangeCheck(), rangeCheckedFunction(), registerBase(), registerSystemAttributeName(), renameParameterGroup(), renameParamInternal(), reservedValues(), set(), set_attributes(), setDeprecatedVarDocString(), setDocString(), setDocUnit(), setReservedValues(), shouldIgnore(), suppressParameter(), transferParam(), and type().

◆ _show_deprecated_message

bool InputParameters::_show_deprecated_message

private

Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping messages.

Definition at line 1387 of file InputParameters.h.

Referenced by addDeprecatedCoupledVar(), addDeprecatedCustomTypeParam(), addDeprecatedParam(), applyCoupledVar(), applyParameter(), attemptPrintDeprecated(), and clear().

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

include/utils/InputParameters.h
src/utils/InputParameters.C

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ InputParameters() [1/3]

◆ InputParameters() [2/3]

◆ ~InputParameters()

◆ InputParameters() [3/3]

Member Function Documentation

◆ addClassDescription()

◆ addCommandLineParam() [1/3]

◆ addCommandLineParam() [2/3]

◆ addCommandLineParam() [3/3]

◆ addCommandLineParamHelper()

◆ addCoupledVar() [1/3]

◆ addCoupledVar() [2/3]

◆ addCoupledVar() [3/3]

◆ addCoupledVarWithAutoBuild()

The coupling parameter will be passed this vector: "base_0 base_1 base_2 base_3 base_4"

◆ addCustomTypeParam() [1/2]

◆ addCustomTypeParam() [2/2]

◆ addDeprecatedCoupledVar()

◆ addDeprecatedCustomTypeParam()

◆ addDeprecatedParam() [1/6]

◆ addDeprecatedParam() [2/6]

◆ addDeprecatedParam() [3/6]

◆ addDeprecatedParam() [4/6]

◆ addDeprecatedParam() [5/6]

◆ addDeprecatedParam() [6/6]

◆ addOptionalValuedCommandLineParam()

◆ addParam() [1/7]

◆ addParam() [2/7]

◆ addParam() [3/7]

◆ addParam() [4/7]

◆ addParam() [5/7]

◆ addParam() [6/7]

◆ addParam() [7/7]

◆ addParamNamesToGroup()

◆ addPrivateParam() [1/6]

◆ addPrivateParam() [2/6]

◆ addPrivateParam() [3/6]

◆ addPrivateParam() [4/6]

◆ addPrivateParam() [5/6]

◆ addPrivateParam() [6/6]

◆ addRangeCheckedParam() [1/2]

◆ addRangeCheckedParam() [2/2]

◆ addRelationshipManager()

◆ addRequiredCommandLineParam()

◆ addRequiredCoupledVar()

◆ addRequiredCoupledVarWithAutoBuild()

◆ addRequiredCustomTypeParam()

◆ addRequiredParam() [1/6]

◆ addRequiredParam() [2/6]

◆ addRequiredParam() [3/6]

◆ addRequiredParam() [4/6]

◆ addRequiredParam() [5/6]

◆ addRequiredParam() [6/6]

◆ addRequiredRangeCheckedParam()

◆ allowCopy()

◆ appendFunctorDescription()

◆ applyCoupledVar()

◆ applyParameter()

◆ applyParameters()

◆ applySpecificParameters()

◆ areAllRequiredParamsValid()

◆ at() [1/2]

◆ at() [2/2]

◆ attemptPrintDeprecated()

◆ blockFullpath()

◆ blockLocation()

◆ callMooseErrorHelper()

◆ checkConsistentType()

◆ checkForRename()