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.

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

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

std::optional< std::string >	queryDeprecatedParamMessage (const std::string &name) const

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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

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.

void	moveParamToGroup (const std::string &name, const std::string &group_name)
	This method moves a single parameter to a different group than the one it is already assigned to (for example, in a derived class intentionally re-grouping a base class's parameter).

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

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

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.

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

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

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

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.

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

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

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

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

bool	isMooseBaseObject () const

const std::string *	queryObjectType () const

const std::string &	getObjectType () const

const std::string &	getObjectName () const

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

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

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

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

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

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

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

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

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

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

bool	isKokkosObject () const
	Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_object_param is valid.

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

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

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

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

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

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

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

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

bool	hasBase () const

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

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

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

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.

void	clearRelationshipManagers ()
	Clears all currently registered RelationshipManagers.

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

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.

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.

std::optional< std::pair< bool, std::string > >	parameterRangeCheck (const Parameters::Value &value, const std::string &long_name, const std::string &short_name, const bool include_param_path)
	Performs a range check on the parameter (which must have a range check)

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

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.

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

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

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

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

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

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

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

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

void	setCoupledVar (const std::string &coupling_name, const std::string &value)
	Set a coupled variable parameter to a single variable name.

void	setCoupledVar (const std::string &coupling_name, const std::vector< VariableName > &values)
	Set a coupled variable parameter to multiple variable names.

const std::vector< VariableName > &	getCoupledVar (const std::string &coupling_name) const
	Get a coupled variable parameter.

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

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

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

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

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

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

void	applyCommonUserSetParameters (const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
	Variant of applyParameters that only applies parameters explicitly set by the user in `common` (i.e.

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

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

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.

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

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

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

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

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.

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

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

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

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

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

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

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

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

std::string	paramLocationPrefix (const std::string &param) const
	Returns a prefix containing the parameter name and location (if available)

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

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with the object information, if available.

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits a parameter error prefixed with the parameter location and object information if available.

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.

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.

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 \emph parameter name.

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.

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.

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)

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

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

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

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.

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

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.

bool	isFinalized () const

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

std::optional< std::string >	setupVariableNames (std::vector< VariableName > &names, const hit::Node &node, const Moose::PassKey< Moose::Builder >)
	Entrypoint for the Builder to setup a std::vector<VariableName> parameter, which will setup the default variable names if appropriate.

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<>
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 &)

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 UP_T >
std::optional< std::pair< bool, std::string > >	rangeCheck (const std::string &full_name, const std::string &short_name, const InputParameters::Parameter< T > &param, const bool include_param_path=true)
	Runs a range on the supplied parameter if it exists and throws an error if that check fails.

template<typename T , typename UP_T >
std::optional< std::pair< bool, std::string > >	rangeCheck (const std::string &full_name, const std::string &short_name, const InputParameters::Parameter< std::vector< T > > &param, const bool include_param_path=true)


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.

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.

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.

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.

bool	collapseSyntaxNesting () const


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

bool	mooseObjectSyntaxVisibility () const


InputParameters &	operator= (const InputParameters &rhs)

InputParameters &	operator+= (const InputParameters &rhs)

Static Public Member Functions
template<>
const MooseEnum &	getParamHelper (const std::string &name, const InputParameters &pars)

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

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

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


template<typename T >
static const T &	getParamHelper (const std::string &name, const InputParameters &pars)

Protected Attributes
map_type	_values

Private Member Functions
	InputParameters ()

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

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

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

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)

std::pair< std::string, const hit::Node * >	paramMessageContext (const std::string &param) const
	Get the context associated with a parameter for a message.

std::string	paramMessagePrefix (const std::string &param) const
	Get a prefix for messages associated with a parameter.

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.

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

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.

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.

void	callMooseError (std::string msg, const bool with_prefix=true, const hit::Node *node=nullptr, const bool show_trace=true) const
	Internal helper for calling back to mooseError(), ideally from the underlying MooseBase object if it is available (for more context)

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

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

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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 67 of file InputParameters.h.

Constructor & Destructor Documentation

◆ InputParameters() [1/3]

InputParameters::InputParameters ( const InputParameters & rhs )

Definition at line 48 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 54 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 37 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 81 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::initializer_list< typename T::value_type > &	value,
		const std::string &	doc_string
	)

inline

Definition at line 352 of file InputParameters.h.

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

◆ addCommandLineParam() [2/3]

template<typename T >

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

Definition at line 2060 of file InputParameters.h.

{
  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);
}

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

◆ addCommandLineParam() [3/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 2080 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);
}

◆ 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 1885 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 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 224 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() [2/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 253 of file InputParameters.C.

{
  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() [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 237 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 291 of file InputParameters.C.

{
  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)");
}

Referenced by addRequiredCoupledVarWithAutoBuild().

◆ addCustomTypeParam() [1/2]

template<typename T >

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

Definition at line 1998 of file InputParameters.h.

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

◆ addCustomTypeParam() [2/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 1987 of file InputParameters.h.

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

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

◆ 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 263 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 2008 of file InputParameters.h.

{
  _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;
}

Referenced by ParsedMaterialBase::validParams().

◆ addDeprecatedParam() [1/6]

template<>

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

◆ addDeprecatedParam() [2/6]

template<>

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

◆ addDeprecatedParam() [3/6]

template<>

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

Definition at line 1463 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 1473 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<typename T >

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

Definition at line 2196 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() [6/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 2179 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, value, doc_string);
 
  _params[name]._deprecation_message = deprecation_message;
  _show_deprecated_message = true;
}

Referenced by Moose::commonAdaptivityParams(), AdaptivityAction::validParams(), CommonOutputAction::validParams(), SetupDebugAction::validParams(), TagAuxBase< T >::validParams(), VectorFunctionDirichletBC::validParams(), Executioner::validParams(), FixedPointSolve::validParams(), MooseParsedGradFunction::validParams(), AnnularMesh::validParams(), FileMesh::validParams(), AnnularMeshGenerator::validParams(), BlockDeletionGenerator::validParams(), ParsedSubdomainGeneratorBase::validParams(), PolyLineMeshGenerator::validParams(), RenameBlockGenerator::validParams(), MultiApp::validParams(), Console::validParams(), Exodus::validParams(), Output::validParams(), SampledOutput::validParams(), FEProblemBase::validParams(), PostprocessorDT::validParams(), MultiAppTransfer::validParams(), MultiAppUserObjectTransfer::validParams(), Transfer::validParams(), PropertyReadFile::validParams(), and DerivativeKernelInterface< T >::validParams().

◆ 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 2094 of file InputParameters.h.

{
  mooseAssert(name == "citations" || name == "csg_only" || 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);
}

Referenced by MooseApp::validParams().

◆ addParam() [1/7]

template<>

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

◆ addParam() [2/7]

template<>

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

◆ addParam() [3/7]

template<>

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

Definition at line 1402 of file InputParameters.C.

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

◆ addParam() [4/7]

template<>

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

Definition at line 1411 of file InputParameters.C.

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

◆ addParam() [5/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 1841 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() [6/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 266 of file InputParameters.h.

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

◆ addParam() [7/7]

template<typename T >

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

Definition at line 1864 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;
}

◆ 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 1027 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)
    {
      std::string & group = _params[param_name]._group;
      if (!group.empty() && group == group_name)
        mooseError(
            "The parameter '", param_name, "' has already been added to the group '", group, "'.");
      group = group_name;
    }
    else
      mooseError("Unable to find a parameter with name: ",
                 param_name,
                 " when adding to group ",
                 group_name,
                 '.');
}

◆ addPrivateParam() [1/6]

template<>

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

◆ addPrivateParam() [2/6]

template<>

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

◆ addPrivateParam() [3/6]

template<>

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

Definition at line 1447 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 1455 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<typename T >

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

Definition at line 2024 of file InputParameters.h.

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

◆ addPrivateParam() [6/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 2035 of file InputParameters.h.

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

Referenced by AddControlAction::act(), FEProblemBase::addOutput(), ActionFactory::create(), ActionFactory::getValidParams(), AppFactory::storeAppParams(), Action::validParams(), CreateProblemDefaultAction::validParams(), GlobalParamsAction::validParams(), MooseApp::validParams(), MooseBase::validParams(), MooseObject::validParams(), DefaultConvergenceBase::validParams(), DefaultNonlinearConvergence::validParams(), FunctorNodalCorrector::validParams(), EigenExecutionerBase::validParams(), EigenProblemSolve::validParams(), Executioner::validParams(), InternalSideIndicatorBase::validParams(), BlockRestrictable::validParams(), BoundaryRestrictable::validParams(), BoundaryRestrictableRequired::validParams(), MaterialBase::validParams(), MaterialPropertyInterface::validParams(), MooseMesh::validParams(), MeshGenerator::validParams(), StitchMeshGenerator::validParams(), SurfaceSubdomainsFromAllNormalsGenerator::validParams(), MFEMExecutedObject::validParams(), MFEMFunctorMaterial::validParams(), MFEMMeshGenerator::validParams(), MultiApp::validParams(), FileOutput::validParams(), Output::validParams(), XDA::validParams(), CopyMeshPartitioner::validParams(), MoosePartitioner::validParams(), MoosePreconditioner::validParams(), DisplacedProblem::validParams(), FEProblemBase::validParams(), RelationshipManager::validParams(), ElementReporter::validParams(), GeneralReporter::validParams(), NodalReporter::validParams(), NodalNormalsPreprocessor::validParams(), MooseVariableBase::validParams(), and VectorPostprocessor::validParams().

◆ addRangeCheckedParam() [1/2]

template<typename T >

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

Definition at line 1967 of file InputParameters.h.

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

◆ addRangeCheckedParam() [2/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 1956 of file InputParameters.h.

{
  addParam<T>(name, value, 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 537 of file InputParameters.C.

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

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

◆ 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 2048 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 317 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 306 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 1977 of file InputParameters.h.

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

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

◆ addRequiredParam() [1/6]

template<>

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

◆ addRequiredParam() [2/6]

template<>

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

Definition at line 1342 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() [3/6]

template<>

void InputParameters::addRequiredParam	(	const std::string &	name,
		const MultiMooseEnum &	moose_enum,
		const std::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 1354 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<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 1815 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() [6/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 1831 of file InputParameters.h.

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

◆ 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 1946 of file InputParameters.h.

{
  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 1494 of file InputParameters.h.

1494{ _allow_copy = status; }

TIMPI::status

MPI_Status status

Referenced by ActionWarehouse::printInputFile().

◆ 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 2612 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() + ".";
}

◆ applyCommonUserSetParameters()

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

Variant of applyParameters that only applies parameters explicitly set by the user in common (i.e.

isParamSetByUser() is true). Object-type defaults are therefore never overridden by common-block defaults, only by values the user actually wrote.

Definition at line 1164 of file InputParameters.C.

{
  for (const auto & it : common)
  {
    const std::string & common_name = it.first;
    if (std::find(exclude.begin(), exclude.end(), common_name) != exclude.end())
      continue;
    if (!common.isParamSetByUser(common_name))
      continue;
    applyParameter(common, common_name, allow_private);
  }
 
  for (const auto & var_name : common._coupled_vars)
  {
    if (std::find(exclude.begin(), exclude.end(), var_name) != exclude.end())
      continue;
    if (!common.isParamSetByUser(var_name))
      continue;
    applyCoupledVar(common, var_name);
  }
}

Referenced by FEProblemBase::addOutput().

◆ 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 1223 of file InputParameters.C.

{
  // 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 (hasCoupledVar(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.hasCoupledVar(var_name))
      addCoupledVar(var_name, common.getDocString(var_name));
  }
 
  // Enable deprecated message printing
  _show_deprecated_message = true;
}

Referenced by applyCommonUserSetParameters(), applyParameters(), and applySpecificParameters().

◆ applyParameter()

void InputParameters::applyParameter	(	const InputParameters &	common,
		const std::string &	common_name,
		bool	allow_private = `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 (4) Both cannot be private

Definition at line 1250 of file InputParameters.C.

{
  // 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);
 
  /* 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;
}

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

◆ 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 1132 of file InputParameters.C.

{
  // 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 (const auto & var_name : common._coupled_vars)
  {
    // 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);
  }
}

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

◆ 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 1189 of file InputParameters.C.

{
  // 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);
  }
}

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

◆ 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 440 of file InputParameters.C.

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

Referenced by ActionWarehouse::buildBuildableActions().

◆ at() [1/2]

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

inlineprivate

Definition at line 1470 of file InputParameters.h.

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

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

◆ at() [2/2]

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

inlineprivate

Definition at line 1477 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);
  }

◆ 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 1634 of file InputParameters.C.

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

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), AddActionComponentAction::AddActionComponentAction(), checkParams(), MooseObjectAction::MooseObjectAction(), FVRelationshipManagerInterface::parameterError(), and NEML2Action::printSummary().

◆ 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 1626 of file InputParameters.C.

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

◆ callMooseError()

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

private

Internal helper for calling back to mooseError(), ideally from the underlying MooseBase object if it is available (for more context)

Definition at line 1955 of file InputParameters.C.

{
  // Find the context of the app if we can. This will let our errors be
  // prefixed by the multiapp name (if applicable) and will flush the
  // console before outputting an error
  MooseApp * app = nullptr;
  if (isMooseBaseObject() && have_parameter<MooseApp *>(MooseBase::app_param))
    app = get<MooseApp *>(MooseBase::app_param);
 
  MooseBase::callMooseError(app, *this, msg, with_prefix, node, show_trace);
}

Referenced by mooseError(), and paramError().

◆ 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 2109 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()

const 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 1852 of file InputParameters.C.

{
  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;
}

Referenced by applyParameter(), at(), at(), checkConsistentType(), checkParams(), ScalarCoupleable::checkVar(), Coupleable::checkVar(), commandLineParamSet(), Coupleable::coupledComponents(), ScalarCoupleable::coupledScalarComponents(), declareControllable(), defaultCoupledValue(), get(), get(), getCheckedPointerParam(), getCommandLineMetadata(), getControllableExecuteOnTypes(), getCoupledVar(), getDescription(), getDocString(), getDocUnit(), getGroupName(), getMooseType(), getParamHelper(), 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(), queryDeprecatedParamMessage(), rangeCheckedFunction(), reservedValues(), set(), set_attributes(), setCoupledVar(), setDocString(), setDocUnit(), setGlobalCommandLineParam(), setReservedValues(), shouldIgnore(), suppressParameter(), transferParam(), and type().

◆ checkParamName()

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

private

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

Definition at line 1673 of file InputParameters.C.

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

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

◆ 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 589 of file InputParameters.C.

{
  const std::string parampath = blockFullpath() != "" ? blockFullpath() : parsing_syntax;
 
  // Required parameters
  std::vector<std::string> required_param_errors;
  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;
 
      required_param_errors.push_back("missing required parameter '" + parampath + "/" +
                                      param_name + "'\n\tDoc String: \"" +
                                      getDocString(param_name) + "\"");
    }
  }
 
  if (required_param_errors.size())
    mooseError(MooseUtils::stringJoin(required_param_errors, "\n"));
 
  // Range checked parameters
  for (const auto & [name, param_ptr] : *this)
  {
    if (const auto error = parameterRangeCheck(*param_ptr, parampath + "/" + name, name, false))
    {
      if (error->first)
        paramError(name, error->second);
      else
        mooseError("For range checked parameter '" + name + "': " + error->second);
    }
  }
 
  // Controllable parameters
  for (const auto & param_name : getControllableParameters())
  {
    if (isPrivate(param_name))
      paramError(param_name,
                 "private parameter '" + paramFullpath(param_name) + "' marked controllable");
 
    std::optional<std::string> error;
    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 (error)
      paramError(param_name, *error);
  }
}

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

◆ clear()

void InputParameters::clear ( )

overridevirtual

Reimplemented from libMesh::Parameters.

Definition at line 64 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;
  _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 797 of file InputParameters.h.

797{ _buildable_rm_types.clear(); }

Referenced by ElemSideNeighborLayersGeomTester::validParams().

◆ collapseSyntaxNesting() [1/2]

bool InputParameters::collapseSyntaxNesting ( ) const

Definition at line 566 of file InputParameters.C.

{
  return _collapse_nesting;
}

◆ collapseSyntaxNesting() [2/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 560 of file InputParameters.C.

{
  _collapse_nesting = collapse;
}

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

◆ 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 1111 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;
}

Referenced by CommandLine::populateCommandLineParams().

◆ 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 891 of file InputParameters.h.

  {
    return _coupled_vars.begin();
  }

Referenced by applySpecificParameters(), Coupleable::Coupleable(), LazyCoupleable::LazyCoupleable(), and ScalarCoupleable::ScalarCoupleable().

◆ coupledVarsEnd()

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

inline

Definition at line 895 of file InputParameters.h.

  {
    return _coupled_vars.end();
  }

Referenced by applySpecificParameters(), Coupleable::Coupleable(), LazyCoupleable::LazyCoupleable(), and ScalarCoupleable::ScalarCoupleable().

◆ declareControllable()

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

Declare the given parameters as controllable.

Definition at line 456 of file InputParameters.C.

{
  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.");
  }
}

Referenced by Moose::commonAdaptivityParams(), AuxKernelBase::validParams(), ConstantAux::validParams(), AuxScalarKernel::validParams(), ConstantScalarAux::validParams(), ADArrayDirichletBC::validParams(), ADDirichletBC::validParams(), ADPenaltyDirichletBC::validParams(), ArrayDirichletBC::validParams(), DirichletBC::validParams(), NeumannBCTempl< is_ad >::validParams(), PenaltyDirichletBC::validParams(), VectorDirichletBC::validParams(), Damper::validParams(), ConstantPointSource::validParams(), DiracKernelBase::validParams(), VectorConstantPointSource::validParams(), ConstantFunction::validParams(), PiecewiseTabularBase::validParams(), FVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), FVBodyForce::validParams(), InterfaceKernelBase::validParams(), BodyForceTempl< is_ad >::validParams(), ReactionTempl< is_ad >::validParams(), VectorBodyForce::validParams(), TorchScriptUserObject::validParams(), LinearFVBoundaryCondition::validParams(), GenericConstant2DArrayTempl< is_ad >::validParams(), GenericConstantArray::validParams(), GenericConstantMaterialTempl< is_ad >::validParams(), GenericConstantVectorMaterialTempl< is_ad >::validParams(), MaterialBase::validParams(), PiecewiseLinearInterpolationMaterial::validParams(), MultiApp::validParams(), ConstantRate::validParams(), PenaltyDirichletNodalKernel::validParams(), Output::validParams(), ConstantPostprocessor::validParams(), FunctionValuePostprocessor::validParams(), ParsedPostprocessor::validParams(), FEProblemBase::validParams(), ControllableInputTimes::validParams(), IterationAdaptiveDT::validParams(), TimeStepper::validParams(), Transfer::validParams(), and UserObjectBase::validParams().

◆ defaultCoupledValue() [1/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 867 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;
}

◆ defaultCoupledValue() [2/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 876 of file InputParameters.C.

{
  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);
}

Referenced by MooseServer::addParametersToList(), applyCoupledVar(), Coupleable::getADDefaultValue(), ScalarCoupleable::getADDefaultValue(), Coupleable::getADDefaultVectorValue(), Coupleable::getDefaultArrayValue(), ScalarCoupleable::getDefaultValue(), Coupleable::getDefaultValue(), Coupleable::getDefaultVectorValue(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), JsonSyntaxTree::setParams(), setupVariableNames(), and transferParam().

◆ deprecateCoupledVar()

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

Definition at line 1844 of file InputParameters.C.

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

Referenced by CoupledGradientMaterialTempl< is_ad >::validParams(), and ConservativeAdvectionTempl< is_ad >::validParams().

◆ deprecateParam()

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

Definition at line 1836 of file InputParameters.C.

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

Referenced by CoupledGradientMaterialTempl< is_ad >::validParams(), and ConservativeAdvectionTempl< is_ad >::validParams().

◆ 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 674 of file InputParameters.C.

{
  mooseAssert(!isFinalized(), "Already finalized");
 
  checkParams(parsing_syntax);
 
  // Set parameters that represent file types
  for (const auto & name_value : *this)
  {
    const auto & param_name = name_value.first;
    const auto & param_value = name_value.second;
 
    // Helper for setting a file typed parameter value
    const auto set_filename = [&](auto & value)
    {
      constexpr bool is_data_file_name =
          std::is_same_v<std::decay_t<decltype(value)>, DataFileName>;
 
      // We have behavior (which is gross) that requires that for
      // everything but DataFileName, if the value is empty we
      // don't bother looking for it
      if constexpr (!is_data_file_name)
      {
        if (value.empty())
          return;
      }
 
      // Setup options for searching for the path
      Moose::DataFileUtils::GetPathOptions options;
      // Associate relative path searches with the folder
      // that input file that has this parameter is located
      options.base = getFileBase(param_name);
      // If we don't explicitly have a DataFileName parameter,
      // we only want to augment cases where a data name is
      // explicitly set (like moose:file). We don't want to
      // search all other data. To presere previous behavior,
      // we also don't want to error if nothing is found; for
      // example if a relative or absolute path is not found.
      // The only time we'll error is if the data name is
      // explicitly set and the path doesn't exist in the data
      // or if that data name isn't registered.
      if constexpr (!is_data_file_name)
      {
        options.search_all_data = false;
        options.graceful = true;
      }
 
      Moose::DataFileUtils::Path path;
      try
      {
        Moose::ScopedThrowOnError scoped_throw_on_error;
        path = Moose::DataFileUtils::getPath(value, options);
      }
      catch (std::exception & e)
      {
        paramError(param_name, e.what());
      }
 
      value = path.path;
      at(param_name)._data_file_name_path = path;
    };
 
#define set_if_filename(type)                                                                      \
  else if (auto type_value = dynamic_cast<Parameters::Parameter<type> *>(param_value.get()))       \
      set_filename(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_filename(value)
 
    if (false)
      ;
    set_if_filename(FileName);
    set_if_filename(FileNameNoExtension);
    set_if_filename(MeshFileName);
    set_if_filename(MatrixFileName);
    set_if_filename(DataFileName);
#undef set_if_filename
  }
 
  _finalized = true;
}

Referenced by Factory::initialize().

◆ 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 2351 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("Parameters ",
               param1,
               " and/or ",
               param2 + " are controllable parameters and cannot be retireved using "
                        "the MooseObject::getParam/InputParameters::get methods for pairs");
 
  if (v1.size() != v2.size())
    paramError(param1,
               "Vector parameters ",
               param1,
               "(size: ",
               v1.size(),
               ") and " + 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 2401 of file InputParameters.h.

{
  const std::string name_str(name_in);
  const auto & name = checkForRename(name_str);
 
  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 904 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;
}

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

◆ getBase()

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

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

Set via registerBase().

Definition at line 505 of file InputParameters.C.

{
  if (!have_parameter<std::string>(MooseBase::moose_base_param))
    mooseError("InputParameters::getBase(): Parameters do not have base; one needs to be set with "
               "registerBase()");
  return get<std::string>(MooseBase::moose_base_param);
}

Referenced by ActionWarehouse::addActionBlock(), AuxiliarySystem::addKernel(), FEProblemBase::addMaterialHelper(), JsonSyntaxTree::addParameters(), AddActionComponentAction::addRelationshipManagers(), MFEMProblem::addTransfer(), MooseServer::addValuesToList(), MooseBase::getBase(), MooseServer::getHoverDisplayText(), MooseServer::getObjectParameters(), and MooseBase::messagePrefix().

◆ 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 554 of file InputParameters.C.

{
  return _buildable_rm_types;
}

Referenced by Action::addRelationshipManagers().

◆ getBuildableTypes()

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

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

Definition at line 546 of file InputParameters.C.

{
  return _buildable_types;
}

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

◆ 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 1799 of file InputParameters.h.

{
  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)
    mooseError("Parameter ", name, " is NULL.\n", error_string);
  return param;
}

Referenced by Coupleable::Coupleable(), Postprocessor::declareValue(), MooseBase::getCheckedPointerParam(), ElementIDInterface::getElementID(), ElementIDInterface::getElementIDByName(), ElementIDInterface::getElementIDNeighbor(), ElementIDInterface::getElementIDNeighborByName(), AuxKernelBase::getVariableHelper(), MooseVariableInterface< T >::MooseVariableInterface(), ScalarCoupleable::ScalarCoupleable(), and TaggingInterface::TaggingInterface().

◆ getClassDescription()

std::string InputParameters::getClassDescription ( ) const

Returns the class description.

Definition at line 129 of file InputParameters.C.

{
  return _class_description;
}

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

◆ getCommandLineMetadata()

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

Returns: The command line metadata for the parameter name.

Definition at line 1100 of file InputParameters.C.

{
  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;
}

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

◆ getControllableExecuteOnTypes()

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

Return the allowed execute flags for a controllable parameter.

Definition at line 485 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 1710 of file InputParameters.C.

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

Referenced by checkParams(), and get().

◆ getCoupledVar()

const std::vector< VariableName > & InputParameters::getCoupledVar ( const std::string & coupling_name ) const

Get a coupled variable parameter.

Parameters

coupling_name The name of the coupling parameter to get.

Definition at line 847 of file InputParameters.C.

{
  const auto & actual_name = checkForRename(coupling_name);
 
  if (!hasCoupledVar(actual_name))
    mooseError("Unable to get coupled variable parameter '",
               coupling_name,
               "' because it was not added with addCoupledVar or addRequiredCoupledVar.");
 
  return get<std::vector<VariableName>>(actual_name);
}

◆ getCoupledVariableParamNames()

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

inline

Return the coupled variable parameter names.

Definition at line 903 of file InputParameters.h.

903{ return _coupled_vars; }

◆ getDescription()

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

Get the documentation string for a parameter.

Definition at line 1332 of file InputParameters.C.

{
  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;
}

Referenced by transferParam().

◆ getDocString()

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

Returns the documentation string for the specified parameter name.

Definition at line 324 of file InputParameters.C.

{
  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;
}

Referenced by MooseServer::addParametersToList(), applyCoupledVar(), checkParams(), MooseServer::getHoverDisplayText(), CommandLine::populateCommandLineParams(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), and JsonSyntaxTree::setParams().

◆ getDocUnit()

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

Returns the documentation unit string for the specified parameter name.

Definition at line 356 of file InputParameters.C.

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

Referenced by MooseServer::getHoverDisplayText(), YAMLFormatter::printParams(), and JsonSyntaxTree::setParams().

◆ 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 756 of file InputParameters.C.

{
  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)
  {
    const std::string error = "Input context was set via a command-line argument and does not have "
                              "sufficient context for determining a file path.";
    if (param_name)
      paramError(*param_name, error);
    else
      mooseError(error);
  }
 
  return std::filesystem::absolute(std::filesystem::path(hit_node->filename()).parent_path());
}

Referenced by finalize().

◆ 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 1122 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();
}

Referenced by InputFileFormatter::printParams(), YAMLFormatter::printParams(), and JsonSyntaxTree::setParams().

◆ getGroupParameters()

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

Return names of parameters within a group.

Definition at line 1691 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

inline

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

Definition at line 1345 of file InputParameters.h.

1345{ return _hit_node; }

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

◆ getHitNode() [2/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 1642 of file InputParameters.C.

{
  return at(param)._hit_node;
}

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

◆ 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 930 of file InputParameters.C.

{
  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;
}

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

◆ getNewToDeprecatedVarMap()

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

inline

Return the new to deprecated variable name map.

Definition at line 908 of file InputParameters.h.

  {
    return _new_to_deprecated_coupled_vars;
  }

◆ getObjectName()

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

Returns: The underlying owning object name, for MooseBase objects with parameters

Definition at line 1019 of file InputParameters.C.

{
  if (!have_parameter<std::string>(MooseBase::name_param))
    ::mooseError("InputParameters::getObjectName(): Missing '", MooseBase::name_param, "' param");
  return get<std::string>(MooseBase::name_param);
}

Referenced by FEProblemBase::addConstraint(), MooseBase::messagePrefix(), operator=(), OrientedBoxInterface::OrientedBoxInterface(), OutputInterface::OutputInterface(), and InputParametersChecksUtils< C >::warnInconsistent().

◆ getObjectType()

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

Returns: The underlying owning object type, for MooseBase objects with parameters

Will error if a type does not exist

Definition at line 1011 of file InputParameters.C.

{
  if (const auto type_ptr = queryObjectType())
    return *type_ptr;
  ::mooseError("InputParameters::getObjectType(): Missing '", MooseBase::type_param, "' param");
}

Referenced by MooseBase::messagePrefix(), operator=(), and InputParametersChecksUtils< C >::warnInconsistent().

◆ getParametersList()

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

Returns: list of all parameters

Definition at line 1701 of file InputParameters.C.

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

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

◆ getParamHelper() [1/5]

template<typename T >

const T & InputParameters::getParamHelper	(	const std::string &	name,
		const InputParameters &	pars
	)

static

Definition at line 2327 of file InputParameters.h.

{
  const auto & name = pars.checkForRename(name_in);
 
  if (!pars.isParamValid(name))
    pars.mooseError("The parameter \"", name, "\" is being retrieved before being set.");
 
  return pars.get<T>(name);
}

◆ getParamHelper() [2/5]

template<>

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

static

◆ getParamHelper() [3/5]

template<>

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

static

◆ getParamHelper() [4/5]

template<>

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

static

Definition at line 1590 of file InputParameters.C.

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

◆ getParamHelper() [5/5]

template<>

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

static

Definition at line 1599 of file InputParameters.C.

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

◆ 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 521 of file InputParameters.C.

{
  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");
}

Referenced by MFEMProblem::addPostprocessor(), MFEMProblem::addVectorPostprocessor(), and AttribSystem::initFrom().

◆ getVecMooseType()

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

Definition at line 960 of file InputParameters.C.

{
  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;
}

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

◆ hasBase()

bool InputParameters::hasBase ( ) const

Returns: Whether or not the object has a registered base

The base is registered with registerBase()

Definition at line 499 of file InputParameters.C.

{
  return have_parameter<std::string>(MooseBase::moose_base_param);
}

Referenced by ActionWarehouse::addActionBlock(), JsonSyntaxTree::addParameters(), MooseServer::addValuesToList(), MooseServer::getHoverDisplayText(), MooseServer::getObjectParameters(), MooseBase::hasBase(), and MooseBase::messagePrefix().

◆ hasCoupledValue()

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

inline

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 934 of file InputParameters.h.

  {
    mooseDeprecated("InputParameters::hasCoupledValue() is deprecated. Use "
                    "InputParameters::hasCoupledVar() instead.");
    return hasCoupledVar(coupling_name);
  }

◆ hasCoupledVar()

bool InputParameters::hasCoupledVar ( 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 821 of file InputParameters.C.

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

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

◆ hasDefault()

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

Return whether a parameter has a default.

Definition at line 806 of file InputParameters.C.

{
  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;
}

Referenced by transferParam().

◆ 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 860 of file InputParameters.C.

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

Referenced by MooseServer::addParametersToList(), applyCoupledVar(), Coupleable::coupledComponents(), hasDefault(), Coupleable::isCoupledConstant(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), JsonSyntaxTree::setParams(), and transferParam().

◆ 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 2411 of file InputParameters.h.

{
  const std::string name_str(name_in);
  const auto & name = checkForRename(name_str);
 
  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 2146 of file InputParameters.h.

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

Referenced by AddElementalFieldAction::validParams().

◆ 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 1657 of file InputParameters.C.

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

Referenced by paramLocationPrefix().

◆ isCommandLineParameter()

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

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

Definition at line 1085 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 478 of file InputParameters.C.

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

Referenced by JsonSyntaxTree::setParams(), and transferParam().

◆ isFinalized()

bool InputParameters::isFinalized ( ) const

inline

Returns: Whether or not finalize() has been called

Definition at line 1358 of file InputParameters.h.

1358{ return _finalized; }

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

◆ isFunctorNameType()

template<typename T >

constexpr bool InputParameters::isFunctorNameType ( )

staticconstexprprivate

Definition at line 2605 of file InputParameters.h.

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

◆ isKokkosObject()

bool InputParameters::isKokkosObject ( ) const

Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_object_param is valid.

Definition at line 433 of file InputParameters.C.

{
  return isParamValid(MooseBase::kokkos_object_param);
}

Referenced by AddBCAction::act(), AddFunctionAction::act(), AddKernelAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddMaterialAction::act(), AddNodalKernelAction::act(), AddPostprocessorAction::act(), AddReporterAction::act(), AddUserObjectAction::act(), AddVectorPostprocessorAction::act(), FEProblemBase::addMaterialHelper(), and MooseObject::isKokkosObject().

◆ isMooseBaseObject()

bool InputParameters::isMooseBaseObject ( ) const

Returns: Whether or not these parameters are for a MooseBase object, that is, one with a name and type.

Needed so that we can produce richer errors from within InputParameters that have the context of the underlying object, if possible.

Definition at line 995 of file InputParameters.C.

{
  return have_parameter<std::string>(MooseBase::type_param) &&
         get<std::string>(MooseBase::type_param).size() &&
         have_parameter<std::string>(MooseBase::name_param);
}

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

◆ 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 1325 of file InputParameters.C.

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

Referenced by FEProblemBase::addOutput(), and MooseMeshUtils::copyIntoMesh().

◆ isParamDeprecated()

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

Returns True if the parameters is deprecated.

Definition at line 425 of file InputParameters.C.

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

Referenced by MooseServer::addParametersToList(), MooseServer::getRequiredParamsText(), and JsonSyntaxTree::setParams().

◆ isParamRequired()

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

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

Definition at line 370 of file InputParameters.C.

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

Referenced by areAllRequiredParamsValid(), checkParams(), MooseServer::getCompletionItemKind(), MooseServer::getRequiredParamsText(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), JsonSyntaxTree::setParams(), and transferParam().

◆ 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 418 of file InputParameters.C.

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

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

◆ 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 1308 of file InputParameters.C.

{
  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;
}

Referenced by CreateProblemAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SplitMeshAction::act(), FEProblemBase::addOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), applyCommonUserSetParameters(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PiecewiseTabularInterface::buildFromFile(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), AddVariableAction::init(), Console::initialSetup(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseBase::isParamSetByUser(), MultiApp::keepSolutionDuringRestore(), LayeredBase::LayeredBase(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MultiApp::MultiApp(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestPointBase< UserObjectType, BaseType >::NearestPointBase(), paramSetByUser(), PiecewiseTabularInterface::PiecewiseTabularInterface(), MooseMesh::prepare(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MooseMesh::setCoordSystem(), TransientBase::setupTimeIntegrator(), Transfer::Transfer(), TransientBase::TransientBase(), MooseUtils::variableFEType(), VectorBodyForce::VectorBodyForce(), vectorFunctionDim(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

◆ 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 386 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 449 of file InputParameters.C.

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

Referenced by MooseServer::addParametersToList(), applyParameter(), checkParams(), Moose::Builder::extractParams(), MooseServer::getRequiredParamsText(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), InputFileFormatter::printParams(), YAMLFormatter::printParams(), JsonSyntaxTree::setParams(), DumpObjectsProblem::stringifyParameters(), and transferParam().

◆ isRangeChecked()

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

Return whether a parameter has a range check.

Definition at line 792 of file InputParameters.C.

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

Referenced by Moose::Builder::extractParams(), MooseServer::getHoverDisplayText(), YAMLFormatter::printParams(), JsonSyntaxTree::setParams(), and transferParam().

◆ 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 2390 of file InputParameters.h.

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

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

◆ 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 2167 of file InputParameters.h.

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

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

◆ 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 377 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 2155 of file InputParameters.h.

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

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

◆ markControlled()

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

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

◆ mooseError()

template<typename... Args>

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

Emits an error prefixed with the object information, if available.

Definition at line 2502 of file InputParameters.h.

{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  callMooseError(oss.str());
}

Referenced by addCommandLineParamHelper(), addDeprecatedParam(), addParam(), addParamNamesToGroup(), addPrivateParam(), addRequiredParam(), applyParameter(), at(), at(), checkConsistentType(), checkParamName(), checkParams(), commandLineParamSet(), declareControllable(), defaultCoupledValue(), get(), getBase(), getCheckedPointerParam(), getCommandLineMetadata(), getCoupledVar(), getDescription(), getFileBase(), getObjectName(), getObjectType(), getParamHelper(), hasDefault(), isType(), makeParamNotRequired(), makeParamRequired(), moveParamToGroup(), numberDefaultCoupledValues(), operator=(), renameCoupledVarInternal(), renameParamInternal(), setCoupledVar(), setDeprecatedVarDocString(), setDocString(), setGlobalCommandLineParam(), shouldIgnore(), suppressParameter(), transferParam(), type(), and varName().

◆ mooseObjectSyntaxVisibility() [1/2]

bool InputParameters::mooseObjectSyntaxVisibility ( ) const

Definition at line 578 of file InputParameters.C.

{
  return _moose_object_syntax_visibility;
}

◆ mooseObjectSyntaxVisibility() [2/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 572 of file InputParameters.C.

{
  _moose_object_syntax_visibility = visibility;
}

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

◆ moveParamToGroup()

void InputParameters::moveParamToGroup	(	const std::string &	name,
		const std::string &	group_name
	)

This method moves a single parameter to a different group than the one it is already assigned to (for example, in a derived class intentionally re-grouping a base class's parameter).

Parameters

name	name of the parameter to move
group_name	name of the group to move the parameter to

Definition at line 1057 of file InputParameters.C.

{
  if (_params.count(name) == 0)
    mooseError(
        "Unable to find a parameter with name: ", name, " when moving to group ", group_name, '.');
  _params[name]._group = group_name;
}

◆ 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 893 of file InputParameters.C.

{
  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();
}

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

◆ operator+=()

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

Definition at line 180 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 135 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)
  {
    // If _allow_parameter_copy is set, these should be too (see
    // InputParameterWarehouse::addInputParameters)
    const std::string & name = rhs.getObjectName();
    const std::string & type = rhs.getObjectType(); // could be empty
    const std::string name_example = type.size() ? type : "the " + name + " object";
    const std::string type_example = type.size() ? type : "MyObject";
    ::mooseError(
        "Copying of the InputParameters object for ",
        name_example,
        " 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",
        "    ",
        type_example,
        "::",
        type_example,
        "(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;
  _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 1861 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;
}

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

◆ paramError()

template<typename... Args>

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

Emits a parameter error prefixed with the parameter location and object information if available.

Definition at line 2520 of file InputParameters.h.

{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  const auto [prefix, node] = paramMessageContext(param);
  callMooseError(prefix + oss.str(), false, node, /* show_trace = */ false);
}

Referenced by PiecewiseTabularInterface::buildFromFile(), checkParams(), Moose::PeriodicBCHelper::checkPeriodicParams(), finalize(), get(), getFileBase(), MooseBase::paramError(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), and MooseUtils::variableFEType().

◆ parameterRangeCheck()

std::optional< std::pair< bool, std::string > > InputParameters::parameterRangeCheck	(	const Parameters::Value &	value,
		const std::string &	long_name,
		const std::string &	short_name,
		const bool	include_param_path
	)

Performs a range check on the parameter (which must have a range check)

Parameters

value	The parameter value
long_name	The full path to the parameter
short_name	The name of the parameter
include_param_path	Whether or not to include the parameter path in errors

Returns: An error, if any; first is whether or not it is a user error and second is the message

Definition at line 649 of file InputParameters.C.

{
#define dynamicCastRangeCheck(type, up_type, long_name, short_name)                                \
  do                                                                                               \
  {                                                                                                \
    if (const auto scalar_p = dynamic_cast<const InputParameters::Parameter<type> *>(&value))      \
      return rangeCheck<type, up_type>(long_name, short_name, *scalar_p, include_param_path);      \
    if (const auto vector_p =                                                                      \
            dynamic_cast<const InputParameters::Parameter<std::vector<type>> *>(&value))           \
      return rangeCheck<type, up_type>(long_name, short_name, *vector_p, include_param_path);      \
  } while (0)
 
  dynamicCastRangeCheck(Real, Real, long_name, short_name);
  dynamicCastRangeCheck(int, long, long_name, short_name);
  dynamicCastRangeCheck(long, long, long_name, short_name);
  dynamicCastRangeCheck(unsigned int, long, long_name, short_name);
#undef dynamicCastRangeCheck
 
  return {};
}

Referenced by checkParams(), and Moose::Builder::extractParams().

◆ 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 1665 of file InputParameters.C.

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

Referenced by checkParams(), and paramLocationPrefix().

◆ paramLocationPrefix()

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

Returns a prefix containing the parameter name and location (if available)

Definition at line 1720 of file InputParameters.C.

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

Referenced by MaterialPropertyInterface::checkBlockAndBoundaryCompatibility().

◆ paramMessage()

template<typename... Args>

std::string InputParameters::paramMessage	(	const std::string &	param,
		Args...	args
	)		const

Returns: A message used as a prefix for output relating to a parameter.

Will first prefix with a path to the parameter, or the parameter that resulted in the creation of these parameters, if available. The message will then be prefixed with the block path to the parameter, if available.

Definition at line 2511 of file InputParameters.h.

{
  std::ostringstream oss;
  moose::internal::mooseStreamAll(oss, std::forward<Args>(args)...);
  return paramMessagePrefix(param) + oss.str();
}

Referenced by MooseBase::paramInfo(), and MooseBase::paramWarning().

◆ paramMessageContext()

std::pair< std::string, const hit::Node * > InputParameters::paramMessageContext ( const std::string & param ) const

private

Get the context associated with a parameter for a message.

Parameters

param The parameter name

Returns: Pair that is the string prefix for the parameter (fullpath) and a pointer to the best hit node that can be associated with the parameter (if any)

Definition at line 1921 of file InputParameters.C.

{
  const hit::Node * node = nullptr;
 
  std::string fullpath;
  // First try to find the parameter
  if (const hit::Node * param_node = getHitNode(param))
  {
    fullpath = param_node->fullpath();
    node = param_node;
  }
  // If no parameter node, hope for a block node
  else if (const hit::Node * block_node = getHitNode())
  {
    node = block_node;
    fullpath = block_node->fullpath() + "/" + param;
  }
  // Didn't find anything, at least use the parameter
  else
    fullpath = param;
 
  return {fullpath + ": ", node};
}

Referenced by paramError(), and paramMessagePrefix().

◆ paramMessagePrefix()

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

private

Get a prefix for messages associated with a parameter.

Will include the best file path possible for the parameter and the parameter's fullpath.

Definition at line 1946 of file InputParameters.C.

{
  auto [prefix, node] = paramMessageContext(param);
  if (node)
    prefix = Moose::hitMessagePrefix(*node) + prefix;
  return prefix;
}

Referenced by paramMessage(), and queryDeprecatedParamMessage().

◆ paramSetByUser()

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

Deprecated method.

Use isParamSetByUser() instead.

Definition at line 1301 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 1091 of file InputParameters.C.

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

Referenced by isParamSetByUser(), and CommandLine::populateCommandLineParams().

◆ 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 1874 of file InputParameters.C.

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

◆ queryDeprecatedParamMessage()

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

Returns: The deprecated parameter message for the given parameter, if any

Definition at line 109 of file InputParameters.C.

{
  const auto & name = checkForRename(name_in);
  if (_show_deprecated_message)
  {
    auto deprecation_message = [this](const auto & name, const auto & message) -> std::string
    { return paramMessagePrefix(name) + message; };
 
    if (_params.count(name) && !libmesh_map_find(_params, name)._deprecation_message.empty())
      return 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 deprecation_message(name_in, it->second.second);
  }
  return {};
}

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

◆ queryObjectType()

const std::string * InputParameters::queryObjectType ( ) const

Returns: The object type represented by these parameters, if any

Definition at line 1003 of file InputParameters.C.

{
  return have_parameter<std::string>(MooseBase::type_param)
             ? &get<std::string>(MooseBase::type_param)
             : nullptr;
}

Referenced by Moose::Builder::extractParams(), and getObjectType().

◆ queryParam()

template<typename T >

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

Query a parameter.

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

Parameters

name	The name of the parameter

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

Definition at line 2320 of file InputParameters.h.

{
  return have_parameter<T>(name) && isParamValid(name) ? &getParamHelper<T>(name, *this) : nullptr;
}

Referenced by MooseBase::queryParam(), and Moose::PeriodicBCHelper::setupManualPeriodicBoundaries().

◆ rangeCheck() [1/2]

template<typename T , typename UP_T >

std::optional< std::pair< bool, std::string > > InputParameters::rangeCheck	(	const std::string &	full_name,
		const std::string &	short_name,
		const InputParameters::Parameter< std::vector< T > > &	param,
		const bool	include_param_path = `true`
	)

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 1634 of file InputParameters.h.

{
  if (!isParamValid(short_name))
    return {};
 
  const auto & range_function = _params[short_name]._range_function;
  if (range_function.empty())
    return {};
 
  FunctionParserBase<UP_T> fp;
  std::vector<std::string> vars;
  if (fp.ParseAndDeduceVariables(range_function, vars) != -1) // -1 for success
    return {{false,
             "Error parsing expression '" + range_function + "' for parameter " + short_name + ""}};
 
  // Fparser parameter buffer
  std::vector<UP_T> parbuf(vars.size());
 
  // parameter vector
  const std::vector<T> & value = param.get();
 
  // 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)
        {
          std::ostringstream oss;
          oss << "Range checking empty vector";
          if (include_param_path)
            oss << " parameter " << full_name;
          oss << "; expression = '" << range_function << "'";
          return {{true, oss.str()}};
        }
 
        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 + "_")
          return {{false, "Error parsing expression '" + range_function + "'"}};
        std::istringstream iss(vars[j]);
        iss.seekg(short_name.size() + 1);
 
        size_t index;
        if (iss >> index && iss.eof())
        {
          if (index >= value.size())
          {
            std::ostringstream oss;
            oss << "Error parsing expression '" + range_function + "'";
            if (include_param_path)
              oss << " for parameter " << full_name;
            oss << "; out of range variable '" + vars[j] << "'";
            return {{true, oss.str()}};
          }
          parbuf[j] = value[index];
        }
        else
          return {{false,
                   "Error parsing expression '" + range_function + "'; invalid variable '" +
                       vars[j] + "'"}};
      }
    }
 
    // 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())
      return {{false, "Error evaluating expression '" + range_function + "'"}};
 
    if (!result)
    {
      std::ostringstream oss;
      oss << "Range check failed";
      if (include_param_path)
        oss << " for parameter " << full_name;
      oss << "; expression = '" << range_function << "'";
      if (need_to_iterate)
        oss << ", component " << i;
      return {{true, oss.str()}};
    }
 
  } while (need_to_iterate && ++i < value.size());
 
  return {};
}

◆ rangeCheck() [2/2]

template<typename T , typename UP_T >

std::optional< std::pair< bool, std::string > > InputParameters::rangeCheck	(	const std::string &	full_name,
		const std::string &	short_name,
		const InputParameters::Parameter< T > &	param,
		const bool	include_param_path = `true`
	)

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

Returns: Optional of whether or not the error is a user error (false = developer error) and the associated error

If include_param_path = true, include the parameter path in the error message

Definition at line 1752 of file InputParameters.h.

{
  if (!isParamValid(short_name))
    return {};
 
  const auto & range_function = _params[short_name]._range_function;
  if (range_function.empty())
    return {};
 
  // Parse the expression
  FunctionParserBase<UP_T> fp;
  if (fp.Parse(range_function, short_name) != -1) // -1 for success
    return {{false,
             "Error parsing expression '" + range_function + "'" + " for parameter " + short_name}};
 
  // 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.get());
  UP_T result = fp.Eval(&value[0]);
  fp.setEpsilon(tmp_eps);
 
  if (fp.EvalError())
    return {{true,
             "Error evaluating expression '" + range_function + "' for parameter " + short_name +
                 "; perhaps you used the wrong variable name?"}};
 
  if (!result)
  {
    std::ostringstream oss;
    oss << "Range check failed";
    if (include_param_path)
      oss << " for parameter " << full_name;
    oss << "; expression = '" << range_function << "', value = " << value[0];
    return {{true, oss.str()}};
  }
 
  return {};
}

◆ 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 799 of file InputParameters.C.

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

Referenced by MooseServer::getHoverDisplayText(), YAMLFormatter::printParams(), JsonSyntaxTree::setParams(), and transferParam().

◆ 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 1729 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 492 of file InputParameters.C.

{
  InputParameters::set<std::string>(MooseBase::moose_base_param) = value;
  _params[MooseBase::moose_base_param]._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 530 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 514 of file InputParameters.C.

{
  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 1828 of file InputParameters.C.

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

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

◆ 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 1802 of file InputParameters.C.

{
  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);
}

Referenced by deprecateCoupledVar(), and renameCoupledVar().

◆ 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 1820 of file InputParameters.C.

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

Referenced by OrientSurfaceMeshGenerator::validParams(), ParsedSubdomainMeshGenerator::validParams(), SideSetsAroundSubdomainGenerator::validParams(), SideSetsBetweenSubdomainsGenerator::validParams(), StitchBoundaryMeshGenerator::validParams(), SurfaceSubdomainsFromAllNormalsGenerator::validParams(), XYZDelaunayGenerator::validParams(), SidesetAroundSubdomainUpdater::validParams(), MultiAppGeneralFieldFunctorTransfer::validParams(), and MultiAppGeneralFieldNearestLocationTransfer::validParams().

◆ 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 1066 of file InputParameters.C.

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

Referenced by LevelSetMeshingHelper::validParams(), and SurfaceSubdomainsDelaunayRemesher::validParams().

◆ 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 1768 of file InputParameters.C.

{
  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);
}

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

◆ 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 1616 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;
}

Referenced by JsonSyntaxTree::setParams().

◆ 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 1605 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 87 of file InputParameters.C.

{
  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;
  }
}

Referenced by applyParameter(), and Moose::Builder::extractParams().

◆ setCoupledVar() [1/2]

void InputParameters::setCoupledVar	(	const std::string &	coupling_name,
		const std::string &	value
	)

Set a coupled variable parameter to a single variable name.

Parameters

coupling_name	The name of the coupling parameter to set.
value	The variable name to set.

Definition at line 827 of file InputParameters.C.

{
  setCoupledVar(coupling_name, std::vector<VariableName>{value});
}

Referenced by setCoupledVar().

◆ setCoupledVar() [2/2]

void InputParameters::setCoupledVar	(	const std::string &	coupling_name,
		const std::vector< VariableName > &	values
	)

Set a coupled variable parameter to multiple variable names.

Parameters

coupling_name	The name of the coupling parameter to set.
values	The variable names to set.

Definition at line 833 of file InputParameters.C.

{
  const auto & actual_name = checkForRename(coupling_name);
 
  if (!hasCoupledVar(actual_name))
    mooseError("Unable to set coupled variable parameter '",
               coupling_name,
               "' because it was not added with addCoupledVar or addRequiredCoupledVar.");
 
  set<std::vector<VariableName>>(actual_name) = values;
}

◆ 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 206 of file InputParameters.C.

{
  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;
  }
}

Referenced by addCoupledVar(), addCoupledVar(), and addCoupledVar().

◆ 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 343 of file InputParameters.C.

{
  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;
}

Referenced by TableOutput::addMultiAppFixedPointIterationEndExecFlag(), Moose::SlepcSupport::getSlepcValidParams(), AuxKernelBase::validParams(), FVBoundedValueConstraint::validParams(), FVIntegralValueConstraint::validParams(), FVPointValueConstraint::validParams(), OrientSurfaceMeshGenerator::validParams(), MultiApp::validParams(), Output::validParams(), MultiAppTransfer::validParams(), and PropertyReadFile::validParams().

◆ 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 363 of file InputParameters.C.

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

Referenced by Output::validParams().

◆ 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 1074 of file InputParameters.C.

{
  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;
}

Referenced by MooseApp::validParams().

◆ 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 1598 of file InputParameters.h.

1599{

1600}

◆ setHitNode() [1/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 1353 of file InputParameters.h.

1353{ _hit_node = &node; }

◆ setHitNode() [2/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 1648 of file InputParameters.C.

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

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

◆ setParameters() [1/2]

void InputParameters::setParameters ( )

inlineprivate

Method to terminate the recursive setParameters definition.

Definition at line 1384 of file InputParameters.h.

1384{}

Referenced by setParameters().

◆ setParameters() [2/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 1624 of file InputParameters.h.

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

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

◆ setParamHelper() [1/17]

template<>

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

private

◆ setParamHelper() [2/17]

template<>

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

private

Definition at line 1530 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 &	,
		FunctionName &	l_value,
		const Real &	r_value
	)

private

◆ setParamHelper() [4/17]

template<>

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

private

Definition at line 1518 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 &	,
		MaterialPropertyName &	l_value,
		const int &	r_value
	)

private

◆ setParamHelper() [6/17]

template<>

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

private

Definition at line 1554 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 Real &	r_value
	)

private

◆ setParamHelper() [8/17]

template<>

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

private

Definition at line 1542 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

◆ setParamHelper() [10/17]

template<>

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

private

Definition at line 1578 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() [11/17]

template<>

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

private

◆ setParamHelper() [12/17]

template<>

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

private

Definition at line 1566 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() [13/17]

template<>

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

private

Definition at line 1506 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() [14/17]

template<>

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

private

Definition at line 1494 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() [15/17]

template<>

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

private

◆ setParamHelper() [16/17]

template<>

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

private

◆ setParamHelper() [17/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 1878 of file InputParameters.h.

{
  l_value = r_value;
}

Referenced by addParam().

◆ 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 1608 of file InputParameters.C.

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

Referenced by OutputInterface::validParams().

◆ setupVariableNames()

std::optional< std::string > InputParameters::setupVariableNames	(	std::vector< VariableName > &	names,
		const hit::Node &	node,
		const Moose::PassKey< Moose::Builder >
	)

Entrypoint for the Builder to setup a std::vector<VariableName> parameter, which will setup the default variable names if appropriate.

Parameters

names	The variable names
node	The hit node that produced this parameter

Returns: An error message, if any

Definition at line 1880 of file InputParameters.C.

{
  // Whether or not a name was found
  bool has_name = false;
  // Whether or not a default value (real) was found
  bool has_default = false;
 
  // Search through the names for values that convert to Real values,
  // which are default values. If defaults are found, set appropriately
  // in the InputParameters object. Keep track of if names or defaults
  // were found because we don't allow having both
  for (const auto i : index_range(names))
  {
    auto & name = names[i];
    Real real_value;
    if (MooseUtils::convert<Real>(name, real_value, false))
    {
      has_default = true;
      defaultCoupledValue(node.path(), real_value, i);
    }
    else
      has_name = true;
  }
 
  if (has_default)
  {
    if (has_name)
      return {"invalid value for '" + node.fullpath() +
              "': coupled vectors where some parameters are reals and others are variables are not "
              "supported"};
 
    // Don't actually use the names if these don't represent names
    names.clear();
  }
 
  return {};
}

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

◆ 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 1681 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");
}

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

◆ 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 2132 of file InputParameters.h.

{
  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;
}

Referenced by AddMFEMComplexBCComponentAction::AddMFEMComplexBCComponentAction(), AddMFEMComplexKernelComponentAction::AddMFEMComplexKernelComponentAction(), MassMatrix::setMassMatrixParams(), ActionComponent::validParams(), MooseObjectAction::validParams(), MortarNodalAuxKernelTempl< ComputeValueType >::validParams(), TagAuxBase< T >::validParams(), Convergence::validParams(), ReporterPointSource::validParams(), Executioner::validParams(), Moose::FunctionBase::validParams(), FVMassMatrix::validParams(), LinearFVAnisotropicDiffusionFunctorNeumannBC::validParams(), Marker::validParams(), MeshGenerator::validParams(), OrientSurfaceMeshGenerator::validParams(), ParsedGenerateNodeset::validParams(), ParsedGenerateSideset::validParams(), SideSetsAroundSubdomainGenerator::validParams(), SideSetsBetweenSubdomainsGenerator::validParams(), SideSetsFromAllNormalsGenerator::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), SideSetsFromNormalsGenerator::validParams(), SideSetsFromPointsGenerator::validParams(), SurfaceSubdomainsFromAllNormalsGenerator::validParams(), ElementSubdomainModifierBase::validParams(), Moose::MFEM::EigensolverBase::validParams(), MFEMMatrixFreeAMS::validParams(), CentroidMultiApp::validParams(), QuadraturePointMultiApp::validParams(), NEML2Assembly::validParams(), NEML2FEInterpolation::validParams(), NEML2PostKernel::validParams(), NEML2PreKernel::validParams(), CSV::validParams(), VariableResidualNormsDebugOutput::validParams(), DiffusionFV::validParams(), FunctorExtremaPositions::validParams(), NodePositions::validParams(), ElementHCurlSemiError::validParams(), ElementHDivSemiError::validParams(), NumNonlinearIterations::validParams(), PseudoTimestep::validParams(), TimestepSize::validParams(), MooseStaticCondensationPreconditioner::validParams(), ExternalProblem::validParams(), AccumulateReporter::validParams(), ParsedScalarReporter::validParams(), ParsedVectorRealReductionReporter::validParams(), ParsedVectorVectorRealReductionReporter::validParams(), SolutionInvalidityReporter::validParams(), Times::validParams(), MultiAppCloneReporterTransfer::validParams(), MultiAppGeneralFieldFunctorTransfer::validParams(), MultiAppGeneralFieldNearestLocationTransfer::validParams(), MultiAppGeneralFieldShapeEvaluationTransfer::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), MultiAppUserObjectTransfer::validParams(), MultiAppVariableValueSamplePostprocessorTransfer::validParams(), DiscreteElementUserObject::validParams(), NearestRadiusLayeredAverage::validParams(), MooseLinearVariableFV< OutputType >::validParams(), MooseVariableFV< OutputType >::validParams(), and CSVReaderVectorPostprocessor::validParams().

◆ 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 2421 of file InputParameters.h.

{
  const auto & name = source_params.checkForRename(name_in);
  const auto p_name = new_name.empty() ? name_in : new_name;
  if (!source_params.have_parameter<T>(name) && !source_params.hasCoupledVar(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.hasCoupledVar(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.hasCoupledVar(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;
}

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

◆ type()

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

Prints the type of the requested parameter by name.

Definition at line 916 of file InputParameters.C.

{
  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();
}

Referenced by MooseServer::addParametersToList(), MooseServer::addValuesToList(), BatchMeshGeneratorAction::checkInputParameterType(), PostprocessorInterface::checkParam(), MooseServer::gatherDocumentDefinitionLocations(), MooseServer::getFileNameTypeValues(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseServer::getNodesByValueAndTypes(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), operator=(), YAMLFormatter::printParams(), and JsonSyntaxTree::setParams().

◆ 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 \emph 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 1737 of file InputParameters.C.

{
  // 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;
}

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< T >::MooseVariableInterface().

Friends And Related Symbol Documentation

◆ ActionWarehouse

friend class ActionWarehouse

friend

Definition at line 1593 of file InputParameters.h.

◆ emptyInputParameters

InputParameters emptyInputParameters ( )

friend

Definition at line 31 of file InputParameters.C.

{
  InputParameters params;
  return params;
}

◆ InputParameterWarehouse

friend class InputParameterWarehouse

friend

Definition at line 1590 of file InputParameters.h.

◆ Parser

friend class Parser

friend

Definition at line 1591 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 1567 of file InputParameters.h.

Referenced by allowCopy(), 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 1553 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 1544 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 1540 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 1557 of file InputParameters.h.

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

◆ _coupled_vars

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

private

The coupled variables set.

Definition at line 1536 of file InputParameters.h.

Referenced by addCoupledVar(), addCoupledVar(), addCoupledVar(), addCoupledVarWithAutoBuild(), addDeprecatedCoupledVar(), addRequiredCoupledVar(), applyCommonUserSetParameters(), applyParameters(), clear(), coupledVarsBegin(), coupledVarsEnd(), getCoupledVariableParamNames(), hasCoupledVar(), 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 1586 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 1583 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 1560 of file InputParameters.h.

Referenced by clear(), InputParameters(), mooseObjectSyntaxVisibility(), 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 1570 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 1580 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 1576 of file InputParameters.h.

Referenced by addDeprecatedParam(), addDeprecatedParam(), checkForRename(), clear(), operator+=(), operator=(), queryDeprecatedParamMessage(), 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 1533 of file InputParameters.h.

Referenced by addCoupledVar(), addCoupledVar(), addCoupledVarWithAutoBuild(), addCustomTypeParam(), addCustomTypeParam(), addDeprecatedCoupledVar(), addDeprecatedCustomTypeParam(), addDeprecatedParam(), addDeprecatedParam(), addParam(), addParam(), addParamNamesToGroup(), addPrivateParam(), addPrivateParam(), addRangeCheckedParam(), addRangeCheckedParam(), addRequiredCustomTypeParam(), addRequiredParam(), addRequiredParam(), addRequiredParam(), addRequiredRangeCheckedParam(), applyParameter(), at(), at(), clear(), declareControllable(), defaultCoupledValue(), defaultCoupledValue(), getAutoBuildVectors(), getControllableParameters(), getDescription(), getDocString(), getDocUnit(), getGroupName(), getGroupParameters(), getParametersList(), hasDefaultCoupledValue(), ignoreParameter(), InputParameters(), isControllable(), isParamDefined(), isParamDeprecated(), isParamRequired(), isParamSetByAddParam(), isParamSetByUser(), isParamValid(), isPrivate(), isRangeChecked(), isType(), makeParamNotRequired(), makeParamRequired(), moveParamToGroup(), numberDefaultCoupledValues(), operator+=(), operator=(), queryDeprecatedParamMessage(), rangeCheck(), 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 1564 of file InputParameters.h.

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

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

◆ applyCommonUserSetParameters()

◆ applyCoupledVar()

◆ applyParameter()

◆ applyParameters()

◆ applySpecificParameters()

◆ areAllRequiredParamsValid()

◆ at() [1/2]

◆ at() [2/2]

◆ blockFullpath()

◆ blockLocation()

◆ callMooseError()

◆ checkConsistentType()

◆ checkForRename()