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

#include <InputParameters.h>

Inheritance diagram for InputParameters:

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

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

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

struct	Metadata

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

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

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

typedef map_type::iterator	iterator

typedef map_type::const_iterator	const_iterator

Public Member Functions
	InputParameters (const InputParameters &rhs)

	InputParameters (const Parameters &rhs)

virtual	~InputParameters ()=default

virtual void	clear () override

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::string	blockLocation () const

std::string	blockFullpath () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const hit::Node *	getHitNode () const

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

bool	isFinalized () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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


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

bool	collapseSyntaxNesting () const


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

bool	mooseObjectSyntaxVisibility () const


InputParameters &	operator= (const InputParameters &rhs)

InputParameters &	operator+= (const InputParameters &rhs)

Static Public Member Functions

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

Protected Attributes
map_type	_values

Private Member Functions
	InputParameters ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Friends
class	InputParameterWarehouse

class	Parser

class	ActionWarehouse

InputParameters	emptyInputParameters ()

Detailed Description

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

Definition at line 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::string &	doc_string
	)

Definition at line 2050 of file InputParameters.h.

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

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

◆ addCommandLineParam() [2/3]

template<typename T >

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

Definition at line 2070 of file InputParameters.h.

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

◆ addCommandLineParam() [3/3]

template<typename T >

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

inline

Definition at line 352 of file InputParameters.h.

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

◆ addCommandLineParamHelper()

template<typename T >

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

private

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

Parameters

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

Definition at line 1875 of file InputParameters.h.

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

◆ addCoupledVar() [1/3]

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

This method adds a coupled variable name pair.

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

Definition at line 253 of file InputParameters.C.

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

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

◆ addCoupledVar() [2/3]

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

This method adds a coupled variable name pair.

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

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

Definition at line 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() [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.

Referenced by addRequiredCoupledVarWithAutoBuild().

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

◆ addCustomTypeParam() [1/2]

template<typename T >

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

Definition at line 1977 of file InputParameters.h.

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

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

◆ addCustomTypeParam() [2/2]

template<typename T >

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

Definition at line 1988 of file InputParameters.h.

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

◆ addDeprecatedCoupledVar()

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

This method adds a deprecated coupled variable name pair.

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

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

Referenced by ParsedMaterialBase::validParams().

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

◆ addDeprecatedParam() [1/6]

template<typename T >

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

Parameters

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

Definition at line 2169 of file InputParameters.h.

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

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

◆ addDeprecatedParam() [2/6]

template<typename T >

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

Definition at line 2186 of file InputParameters.h.

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

◆ addDeprecatedParam() [3/6]

template<>

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

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

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

◆ addDeprecatedParam() [5/6]

template<>

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

◆ addDeprecatedParam() [6/6]

template<>

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

◆ addOptionalValuedCommandLineParam()

template<typename T >

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

Add a command line parameter with an optional value.

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

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

Parameters

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

Definition at line 2084 of file InputParameters.h.

Referenced by MooseApp::validParams().

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

◆ addParam() [1/7]

template<typename T , typename S >

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

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

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

Definition at line 1831 of file InputParameters.h.

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

◆ addParam() [2/7]

template<typename T >

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

Definition at line 1854 of file InputParameters.h.

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

◆ addParam() [3/7]

template<typename T >

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

inline

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

Definition at line 266 of file InputParameters.h.

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

◆ addParam() [4/7]

template<>

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

Definition at line 1388 of file InputParameters.C.

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

◆ addParam() [5/7]

template<>

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

Definition at line 1397 of file InputParameters.C.

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

◆ addParam() [6/7]

template<>

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

◆ addParam() [7/7]

template<>

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

◆ addParamNamesToGroup()

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

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

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

Definition at line 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)
       _params[param_name]._group = group_name;
     else
       mooseError("Unable to find a parameter with name: ",
                  param_name,
                  " when adding to group ",
                  group_name,
                  '.');
 }

◆ addPrivateParam() [1/6]

template<typename T >

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

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

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

Definition at line 2025 of file InputParameters.h.

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

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

◆ addPrivateParam() [2/6]

template<typename T >

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

Definition at line 2014 of file InputParameters.h.

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

◆ addPrivateParam() [3/6]

template<>

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

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

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

◆ addPrivateParam() [5/6]

template<>

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

◆ addPrivateParam() [6/6]

template<>

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

◆ addRangeCheckedParam() [1/2]

template<typename T >

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

Definition at line 1946 of file InputParameters.h.

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

◆ addRangeCheckedParam() [2/2]

template<typename T >

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

Definition at line 1957 of file InputParameters.h.

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

◆ addRelationshipManager()

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

Tells MOOSE about a RelationshipManager that this object needs.

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

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

Parameters

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

Definition at line 537 of file InputParameters.C.

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

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

◆ addRequiredCommandLineParam()

template<typename T >

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

Add parameters for retrieval from the command line.

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

Parameters

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

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

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

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

◆ addRequiredParam() [1/6]

template<typename T >

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

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

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

Definition at line 1805 of file InputParameters.h.

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

◆ addRequiredParam() [2/6]

template<typename T >

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

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

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

Definition at line 1821 of file InputParameters.h.

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

◆ addRequiredParam() [3/6]

template<>

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

Definition at line 1328 of file InputParameters.C.

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

◆ addRequiredParam() [4/6]

template<>

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

Definition at line 1340 of file InputParameters.C.

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

◆ addRequiredParam() [5/6]

template<>

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

◆ addRequiredParam() [6/6]

template<>

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

◆ addRequiredRangeCheckedParam()

template<typename T >

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

These methods add an range checked parameters.

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

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

Referenced by ActionWarehouse::printInputFile().

1484 { _allow_copy = status; }

InputParameters::_allow_copy

bool _allow_copy

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

Definition: InputParameters.h:1557

status

MPI_Status status

◆ appendFunctorDescription()

template<typename T >

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

private

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

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

Referenced by FEProblemBase::addOutput().

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

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

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

 {
   // Disable the display of deprecated message when applying common parameters, this avoids a dump
   // of messages
   _show_deprecated_message = false;
 
   // If the local parameters has a coupled variable, populate it with the value from the common
   // parameters, if the common parameters has the coupled variable too
   if (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;
 }

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

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

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

◆ applyParameters()

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

Method for applying common parameters.

Parameters

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

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

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

See also: CommonOutputAction AddOutputAction

Definition at line 1117 of file InputParameters.C.

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

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

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

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

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

◆ areAllRequiredParamsValid()

bool InputParameters::areAllRequiredParamsValid ( ) const

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

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

Definition at line 440 of file InputParameters.C.

Referenced by ActionWarehouse::buildBuildableActions().

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

◆ at() [1/2]

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

inlineprivate

Definition at line 1460 of file InputParameters.h.

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

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

◆ at() [2/2]

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

inlineprivate

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

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

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

◆ blockLocation()

std::string InputParameters::blockLocation ( ) const

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

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

Referenced by mooseError(), and paramError().

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

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

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

◆ checkForRename()

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

Checks whether the provided name is a renamed parameter name.

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

Parameters

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

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

Definition at line 1837 of file InputParameters.C.

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

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

◆ checkParamName()

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

private

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

Definition at line 1658 of file InputParameters.C.

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

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

◆ checkParams()

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

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

Definition at line 589 of file InputParameters.C.

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

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

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

Referenced by ElemSideNeighborLayersGeomTester::validParams().

788 { _buildable_rm_types.clear(); }

InputParameters::_buildable_rm_types

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

The RelationshipManagers that this object may either build or require.

Definition: InputParameters.h:1543

◆ collapseSyntaxNesting() [1/2]

void InputParameters::collapseSyntaxNesting ( bool collapse )

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

Definition at line 560 of file InputParameters.C.

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

 {
   _collapse_nesting = collapse;
 }

◆ collapseSyntaxNesting() [2/2]

bool InputParameters::collapseSyntaxNesting ( ) const

Definition at line 566 of file InputParameters.C.

 {
   return _collapse_nesting;
 }

◆ commandLineParamSet()

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

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

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

Definition at line 1096 of file InputParameters.C.

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

◆ coupledVarsBegin()

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

inline

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

Definition at line 882 of file InputParameters.h.

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

   {
     return _coupled_vars.begin();
   }

◆ coupledVarsEnd()

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

inline

Definition at line 886 of file InputParameters.h.

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

   {
     return _coupled_vars.end();
   }

◆ declareControllable()

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

Declare the given parameters as controllable.

Definition at line 456 of file InputParameters.C.

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

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

◆ defaultCoupledValue() [1/2]

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

Get the default value for an optionally coupled variable.

Parameters

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

Definition at line 876 of file InputParameters.C.

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

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

◆ defaultCoupledValue() [2/2]

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

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

Parameters

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

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

◆ deprecateCoupledVar()

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

Definition at line 1829 of file InputParameters.C.

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

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

◆ deprecateParam()

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

Definition at line 1821 of file InputParameters.C.

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

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

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

Referenced by Factory::initialize().

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

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

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

◆ getAutoBuildVectors()

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

Returns the auto build vectors for all parameters.

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

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

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

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

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

Referenced by Action::addRelationshipManagers().

 {
   return _buildable_rm_types;
 }

◆ getBuildableTypes()

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

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

Definition at line 546 of file InputParameters.C.

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

 {
   return _buildable_types;
 }

◆ getCheckedPointerParam()

template<typename T >

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

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

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

Definition at line 1789 of file InputParameters.h.

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

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

◆ getClassDescription()

std::string InputParameters::getClassDescription ( ) const

Returns the class description.

Definition at line 129 of file InputParameters.C.

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

 {
   return _class_description;
 }

◆ getCommandLineMetadata()

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

Returns: The command line metadata for the parameter name.

Definition at line 1085 of file InputParameters.C.

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

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

◆ getControllableExecuteOnTypes()

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

Return the allowed execute flags for a controllable parameter.

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

Referenced by checkParams(), and get().

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

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

Referenced by FunctionMaterialBase< is_ad >::FunctionMaterialBase().

894 { return _coupled_vars; }

InputParameters::_coupled_vars

std::set< std::string > _coupled_vars

The coupled variables set.

Definition: InputParameters.h:1526

◆ getDescription()

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

Get the documentation string for a parameter.

Definition at line 1317 of file InputParameters.C.

Referenced by transferParam().

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

◆ getDocString()

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

Returns the documentation string for the specified parameter name.

Definition at line 324 of file InputParameters.C.

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

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

◆ getDocUnit()

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

Returns the documentation unit string for the specified parameter name.

Definition at line 356 of file InputParameters.C.

Referenced by MooseServer::getHoverDisplayText().

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

◆ getFileBase()

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

Returns: A file base to associate with these parameters.

Optionally, an input parameter can be provided via param_name.

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

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

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

Definition at line 756 of file InputParameters.C.

Referenced by finalize().

 {
   mooseAssert(!have_parameter<std::string>("_app_name"),
               "Not currently setup to work with app FileName parameters");
 
   const hit::Node * hit_node = nullptr;
 
   // Context from the individual parameter
   if (param_name)
     hit_node = getHitNode(*param_name);
   // Context from the parameters
   if (!hit_node)
     hit_node = getHitNode();
   // No hit node, so use the cwd (no input files)
   if (!hit_node)
     return std::filesystem::current_path();
 
   // Find any context that isn't command line arguments
   while (hit_node && hit_node->filename() == "CLI_ARGS")
     hit_node = hit_node->parent();
 
   // Failed to find a node up the tree that isn't a command line argument
   if (!hit_node)
   {
     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());
 }

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

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

◆ getGroupParameters()

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

Return names of parameters within a group.

Definition at line 1676 of file InputParameters.C.

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

◆ getHitNode() [1/2]

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

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

Definition at line 1627 of file InputParameters.C.

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

 {
   return at(param)._hit_node;
 }

◆ getHitNode() [2/2]

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

inline

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

Definition at line 1335 of file InputParameters.h.

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

1335 { return _hit_node; }

InputParameters::_hit_node

const hit::Node * _hit_node

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

Definition: InputParameters.h:1573

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

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

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

◆ getNewToDeprecatedVarMap()

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

inline

Return the new to deprecated variable name map.

Definition at line 899 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.

Referenced by FEProblemBase::addConstraint(), MooseBase::messagePrefix(), operator=(), OrientedBoxInterface::OrientedBoxInterface(), and OutputInterface::OutputInterface().

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

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

Referenced by MooseBase::messagePrefix(), and operator=().

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

◆ getParametersList()

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

Returns: list of all parameters

Definition at line 1686 of file InputParameters.C.

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

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

◆ getParamHelper() [1/5]

template<typename T >

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

static

Definition at line 2317 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_in,
		const InputParameters &	pars
	)

Definition at line 1576 of file InputParameters.C.

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

◆ getParamHelper() [3/5]

template<>

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

Definition at line 1585 of file InputParameters.C.

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

◆ getParamHelper() [4/5]

template<>

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

◆ getParamHelper() [5/5]

template<>

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

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

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

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

◆ getVecMooseType()

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

Definition at line 960 of file InputParameters.C.

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

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

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

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

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

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

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

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

◆ hasDefault()

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

Return whether a parameter has a default.

Definition at line 806 of file InputParameters.C.

Referenced by transferParam().

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

◆ hasDefaultCoupledValue()

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

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

Parameters

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

Definition at line 860 of file InputParameters.C.

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

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

◆ have_parameter()

template<typename T >

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

A wrapper around the Parameters base class method.

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

Parameters

name	The name to query the parameter values map with

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

Definition at line 2400 of file InputParameters.h.

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

◆ ignoreParameter()

template<typename T >

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

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

Definition at line 2136 of file InputParameters.h.

Referenced by AddElementalFieldAction::validParams().

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

◆ inputLocation()

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

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

Definition at line 1642 of file InputParameters.C.

Referenced by paramLocationPrefix().

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

◆ isCommandLineParameter()

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

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

Definition at line 1070 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.

Referenced by transferParam().

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

◆ isFinalized()

bool InputParameters::isFinalized ( ) const

inline

Returns: Whether or not finalize() has been called

Definition at line 1348 of file InputParameters.h.

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

1348 { return _finalized; }

InputParameters::_finalized

bool _finalized

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

Definition: InputParameters.h:1576

◆ isFunctorNameType()

template<typename T >

constexpr bool InputParameters::isFunctorNameType ( )

staticprivate

Definition at line 2593 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.

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

 {
   return isParamValid(MooseBase::kokkos_object_param);
 }

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

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

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

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

Referenced by MooseMeshUtils::copyIntoMesh().

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

◆ isParamDeprecated()

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

Returns True if the parameters is deprecated.

Definition at line 425 of file InputParameters.C.

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

◆ isParamRequired()

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

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

Definition at line 370 of file InputParameters.C.

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

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

◆ isParamSetByAddParam()

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

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

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

Definition at line 418 of file InputParameters.C.

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

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

◆ isParamSetByUser()

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

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

Parameters

name	The parameter name

Definition at line 1293 of file InputParameters.C.

Referenced by CreateProblemAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), SplitMeshAction::act(), SystemBase::addVariable(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PiecewiseTabularInterface::buildFromFile(), 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(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::NearestPointBase(), paramSetByUser(), PiecewiseTabularInterface::PiecewiseTabularInterface(), MooseMesh::prepare(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MooseMesh::setCoordSystem(), TransientBase::setupTimeIntegrator(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), vectorFunctionDim(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

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

◆ isParamValid()

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

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

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

Definition at line 386 of file InputParameters.C.

Referenced by ElementIDOutputAction::act(), ReadExecutorParamsAction::act(), CreateExecutionerAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), MeshOnlyAction::act(), MaterialOutputAction::act(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblem::addLineSearch(), MooseObjectWarehouseBase< Indicator >::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addTransfer(), AddVariableAction::addVariable(), SystemBase::addVariable(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), applyParameter(), areAllRequiredParamsValid(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), PNGOutput::calculateRescalingValues(), PostprocessorInterface::checkParam(), checkParams(), Moose::PeriodicBCHelper::checkPeriodicParams(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), Coupleable::coupledVectorTagValues(), FunctorInterface::deduceFunctorName(), ElementMaterialSampler::ElementMaterialSampler(), FileRangeBuilder::FileRangeBuilder(), GapValueAux::GapValueAux(), MooseServer::getCompletionItemKind(), MaterialPropertyInterface::getMaterialDataType(), MaterialPropertyInterface::getMaterialPropertyName(), getParamHelper(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), GhostingUserObject::GhostingUserObject(), hasDefault(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), isKokkosObject(), isParamSetByUser(), MooseBase::isParamValid(), isValid(), LayeredBase::LayeredBase(), LayeredIntegralBase< ElementIntegralVariableUserObject >::LayeredIntegralBase(), LevelSetMeshingHelper::LevelSetMeshingHelper(), SubProblem::markFamilyPRefinement(), UserObjectInterface::mooseObjectError(), MultiApp::MultiApp(), NodeFaceConstraint::NodeFaceConstraint(), InputParametersChecksUtils< BatchMeshGeneratorAction >::parameterConsistent(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseTabularInterface::PiecewiseTabularInterface(), ReporterInterface::possiblyCheckHasReporter(), PseudoTimestep::PseudoTimestep(), queryParam(), rangeCheck(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Moose::PetscSupport::setLineSearchFromParams(), Moose::PetscSupport::setMFFDTypeFromParams(), MooseMesh::setPartitioner(), Moose::PetscSupport::setSolveTypeFromParams(), SideSetsGeneratorBase::setup(), MeshBaseImageSampler::setupImageSampler(), ImageSampler::setupImageSampler(), SetupMeshAction::setupMesh(), Moose::PeriodicBCHelper::setupPeriodicBoundaries(), Moose::SlepcSupport::storeSolveType(), DumpObjectsProblem::stringifyParameters(), BoundaryRestrictableRequired::validParams(), MultiAppGeneralFieldTransfer::validParams(), BoundaryRestrictable::validParams(), Coupleable::vectorTagDofValueHelper(), Coupleable::vectorTagValueHelper(), MeshBaseImageSampler::vtkMagnitude(), ImageSampler::vtkMagnitude(), MeshBaseImageSampler::vtkThreshold(), and ImageSampler::vtkThreshold().

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

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

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

◆ isRangeChecked()

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

Return whether a parameter has a range check.

Definition at line 792 of file InputParameters.C.

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

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

◆ isType()

template<typename T >

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

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

Definition at line 2380 of file InputParameters.h.

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

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

◆ makeParamNotRequired() [1/2]

template<typename T >

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

Changes the parameter to not be required.

Parameters

name	The parameter name

Definition at line 2157 of file InputParameters.h.

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

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

◆ makeParamNotRequired() [2/2]

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

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

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

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

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

◆ markControlled()

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

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

◆ mooseError()

template<typename... Args>

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

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

Definition at line 2490 of file InputParameters.h.

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

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

◆ mooseObjectSyntaxVisibility() [1/2]

void InputParameters::mooseObjectSyntaxVisibility ( bool visibility )

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

Definition at line 572 of file InputParameters.C.

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

 {
   _moose_object_syntax_visibility = visibility;
 }

◆ mooseObjectSyntaxVisibility() [2/2]

bool InputParameters::mooseObjectSyntaxVisibility ( ) const

Definition at line 578 of file InputParameters.C.

 {
   return _moose_object_syntax_visibility;
 }

◆ numberDefaultCoupledValues()

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

Get the number of defaulted coupled value entries.

Parameters

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

Definition at line 893 of file InputParameters.C.

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

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

◆ operator+=()

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

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

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

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

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

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

Referenced by checkParams().

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

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

Referenced by checkParams(), and paramLocationPrefix().

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

◆ paramLocationPrefix()

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

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

Definition at line 1705 of file InputParameters.C.

Referenced by MaterialPropertyInterface::checkBlockAndBoundaryCompatibility().

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

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

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

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

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

Referenced by paramError(), and paramMessagePrefix().

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

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

Referenced by paramMessage(), and queryDeprecatedParamMessage().

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

◆ paramSetByUser()

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

Deprecated method.

Use isParamSetByUser() instead.

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

Referenced by isParamSetByUser().

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

◆ queryDataFileNamePath()

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

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

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

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

Referenced by getObjectType().

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

◆ queryParam()

template<typename T >

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

Query a parameter.

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

Referenced by Moose::PeriodicBCHelper::setupManualPeriodicBoundaries().

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

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

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

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

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

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

◆ rawParamVal()

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

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

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

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

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

◆ renameCoupledVarInternal()

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

private

Definition at line 1787 of file InputParameters.C.

Referenced by deprecateCoupledVar(), and renameCoupledVar().

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

◆ renameParam()

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

Rename a parameter and provide a new documentation string.

Parameters

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

Definition at line 1805 of file InputParameters.C.

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

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

◆ renameParameterGroup()

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

This method renames a parameter group.

Parameters

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

Definition at line 1051 of file InputParameters.C.

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

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

◆ renameParamInternal()

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

private

Definition at line 1753 of file InputParameters.C.

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

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

◆ reservedValues()

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

Get a set of reserved parameter values.

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

Definition at line 1601 of file InputParameters.C.

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

◆ set()

template<typename T >

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

Returns a writable reference to the named parameters.

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

Parameters

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

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

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

Definition at line 1595 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.

Referenced by applyParameter().

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

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

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

Referenced by addCoupledVar().

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

◆ setDocString()

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

Set the doc string of a parameter.

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

Definition at line 343 of file InputParameters.C.

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

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

◆ setDocUnit()

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

Set the unit string of a parameter.

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

Definition at line 363 of file InputParameters.C.

Referenced by Output::validParams().

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

◆ setGlobalCommandLineParam()

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

Sets the command line parameter with name as global.

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

Definition at line 1059 of file InputParameters.C.

Referenced by MooseApp::validParams().

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

◆ setHelper()

template<typename T >

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

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

Definition at line 1588 of file InputParameters.h.

1589 {

1590 }

◆ setHitNode() [1/2]

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

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

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

Definition at line 1633 of file InputParameters.C.

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

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

◆ setHitNode() [2/2]

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

inline

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

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

Definition at line 1343 of file InputParameters.h.

1343 { _hit_node = &node; }

InputParameters::_hit_node

const hit::Node * _hit_node

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

Definition: InputParameters.h:1573

◆ setParameters() [1/2]

template<typename T , typename... Ts>

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

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

Any number of name, value pairs can be supplied.

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

Parameters

name	The name of the first parameter to set

Definition at line 1614 of file InputParameters.h.

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

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

◆ setParameters() [2/2]

void InputParameters::setParameters ( )

inlineprivate

Method to terminate the recursive setParameters definition.

Definition at line 1374 of file InputParameters.h.

Referenced by setParameters().

1374 {}

◆ setParamHelper() [1/17]

template<>

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

private

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

template<>

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

private

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

Referenced by addParam().

 {
   l_value = r_value;
 }

◆ setParamHelper() [4/17]

template<>

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

private

Definition at line 1504 of file InputParameters.C.

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

◆ setParamHelper() [5/17]

template<>

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

private

Definition at line 1516 of file InputParameters.C.

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

◆ setParamHelper() [6/17]

template<>

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

private

Definition at line 1528 of file InputParameters.C.

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

◆ setParamHelper() [7/17]

template<>

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

private

Definition at line 1540 of file InputParameters.C.

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

◆ setParamHelper() [8/17]

template<>

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

private

Definition at line 1552 of file InputParameters.C.

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

◆ setParamHelper() [9/17]

template<>

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

private

Definition at line 1564 of file InputParameters.C.

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

◆ setParamHelper() [10/17]

template<>

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

private

◆ setParamHelper() [11/17]

template<>

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

private

◆ setParamHelper() [12/17]

template<>

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

private

◆ setParamHelper() [13/17]

template<>

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

private

◆ setParamHelper() [14/17]

template<>

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

private

◆ setParamHelper() [15/17]

template<>

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

private

◆ setParamHelper() [16/17]

template<>

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

private

◆ setParamHelper() [17/17]

template<>

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

private

◆ setReservedValues()

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

Provide a set of reserved values for a parameter.

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

Definition at line 1593 of file InputParameters.C.

Referenced by OutputInterface::validParams().

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

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

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

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

◆ suppressParameter()

template<typename T >

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

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

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

Definition at line 2122 of file InputParameters.h.

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

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

◆ transferParam()

template<typename T >

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

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

Parameters

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

Definition at line 2409 of file InputParameters.h.

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

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

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

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

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

◆ varName()

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

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

Parameters

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

Definition at line 1722 of file InputParameters.C.

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

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

Friends And Related Function Documentation

◆ ActionWarehouse

friend class ActionWarehouse

friend

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

◆ Parser

friend class Parser

friend

Definition at line 1581 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 1557 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 1543 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 1534 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 1530 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 1547 of file InputParameters.h.

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

◆ _coupled_vars

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

private

The coupled variables set.

Definition at line 1526 of file InputParameters.h.

Referenced by addCoupledVar(), addCoupledVarWithAutoBuild(), addDeprecatedCoupledVar(), addRequiredCoupledVar(), 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 1576 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 1573 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 1550 of file InputParameters.h.

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

◆ _new_to_deprecated_coupled_vars

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

private

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

Definition at line 1560 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 1570 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 1566 of file InputParameters.h.

Referenced by 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 1523 of file InputParameters.h.

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

Referenced by addDeprecatedCoupledVar(), addDeprecatedCustomTypeParam(), 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()