www.mooseframework.org
Classes | Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | Friends | List of all members
InputParameters Class Reference

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

#include <InputParameters.h>

Inheritance diagram for InputParameters:
[legend]

Classes

struct  CommandLineMetadata
 Structure for storing information about 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 Member Functions

 InputParameters (const InputParameters &rhs)
 
 InputParameters (const Parameters &rhs)
 
virtual ~InputParameters ()=default
 
virtual void clear () override
 
void addClassDescription (const std::string &doc_string)
 This method adds a description of the class that will be displayed in the input file syntax dump. More...
 
std::string getClassDescription () const
 Returns the class description. More...
 
virtual void set_attributes (const std::string &name, bool inserted_only) override
 Override from libMesh to set user-defined attributes on our parameter. More...
 
bool attemptPrintDeprecated (const std::string &name)
 Prints the deprecated parameter message, assuming we have the right flags set. More...
 
template<typename T >
void setHelper (const std::string &name)
 This functions is called in set as a 'callback' to avoid code duplication. More...
 
template<typename T >
T & set (const std::string &name, bool quiet_mode=false)
 Returns a writable reference to the named parameters. More...
 
template<typename T , typename... Ts>
void setParameters (const std::string &name, const T &value, Ts... extra_input_parameters)
 Given a series of parameters names and values, sets each name to the corresponding value. More...
 
template<typename T , typename UP_T >
void rangeCheck (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, std::ostream &oss=Moose::out)
 Runs a range on the supplied parameter if it exists and throws an error if that check fails. More...
 
template<typename T , typename UP_T >
void rangeCheck (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< T >> *param, std::ostream &oss=Moose::out)
 
template<typename T >
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 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
 
const std::vector< std::string > & getCommandLineSyntax (const std::string &name) const
 
CommandLineMetadata::ArgumentType getCommandLineArgumentType (const std::string &name) const
 
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...
 
std::string getGroupName (const std::string &param_name) const
 This method retrieves the group name for the passed parameter name if one exists. More...
 
template<typename T >
void suppressParameter (const std::string &name)
 This method suppresses an inherited parameter so that it isn't required or valid in the derived class. More...
 
template<typename T >
void makeParamRequired (const std::string &name)
 Changes the parameter to be required. More...
 
template<typename T >
void makeParamNotRequired (const std::string &name)
 Changes the parameter to not be required. More...
 
void addCoupledVar (const std::string &name, const std::string &doc_string)
 This method adds a coupled variable name pair. More...
 
void addDeprecatedCoupledVar (const std::string &old_name, const std::string &new_name, const std::string &removal_date="")
 This method adds a deprecated coupled variable name pair. More...
 
void addCoupledVar (const std::string &name, const Real value, const std::string &doc_string)
 This method adds a coupled variable name pair. More...
 
void addCoupledVar (const std::string &name, const std::vector< Real > &value, const std::string &doc_string)
 This method adds a coupled variable name pair. More...
 
std::string getMooseType (const std::string &name) const
 Utility functions for retrieving one of the MooseTypes variables into the common "string" base class. More...
 
std::vector< std::string > getVecMooseType (const std::string &name) const
 
void addRequiredCoupledVar (const std::string &name, const std::string &doc_string)
 This method adds a coupled variable name pair. More...
 
std::string getDocString (const std::string &name) const
 Returns the documentation string for the specified parameter name. More...
 
void setDocString (const std::string &name, const std::string &doc)
 Set the doc string of a parameter. More...
 
bool isParamRequired (const std::string &name) const
 Returns a boolean indicating whether the specified parameter is required or not. More...
 
void makeParamNotRequired (const std::string &name)
 Forces parameter of given name to be not required regardless of type. More...
 
bool isParamValid (const std::string &name) const
 This method returns parameters that have been initialized in one fashion or another, i.e. More...
 
bool isParamSetByAddParam (const std::string &name) const
 Returns whether or not the parameter was set due to addParam. More...
 
bool isParamDeprecated (const std::string &name) const
 Returns True if the parameters is deprecated. More...
 
bool areAllRequiredParamsValid () const
 This method returns true if all of the parameters in this object are valid (i.e. More...
 
std::string type (const std::string &name) const
 Prints the type of the requested parameter by name. More...
 
bool isPrivate (const std::string &name) const
 Returns a Boolean indicating whether the specified parameter is private or not. More...
 
void declareControllable (const std::string &name, std::set< ExecFlagType > execute_flags={})
 Declare the given parameters as controllable. More...
 
void markControlled (const std::string &name)
 Marker a parameter that has been changed by the Control system (this is for output purposes) More...
 
bool isControllable (const std::string &name) const
 Returns a Boolean indicating whether the specified parameter is controllable. More...
 
const std::set< ExecFlagType > & getControllableExecuteOnTypes (const std::string &name) const
 Return the allowed execute flags for a controllable parameter. More...
 
void registerBase (const std::string &value)
 This method must be called from every base "Moose System" to create linkage with the Action System. More...
 
std::optional< std::string > getBase () const
 
void registerSystemAttributeName (const std::string &value)
 This method is used to define the MOOSE system name that is used by the TheWarehouse object for storing objects to be retrieved for execution. More...
 
const std::string & getSystemAttributeName () const
 Get the system attribute name if it was registered. More...
 
void registerBuildableTypes (const std::string &names)
 This method is here to indicate which Moose types a particular Action may build. More...
 
void addRelationshipManager (const std::string &name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback input_parameter_callback=nullptr)
 Tells MOOSE about a RelationshipManager that this object needs. More...
 
void clearRelationshipManagers ()
 Clears all currently registered RelationshipManagers. More...
 
const std::vector< std::string > & getBuildableTypes () const
 Returns the list of buildable types as a std::vector<std::string> More...
 
const std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > & getBuildableRelationshipManagerTypes () const
 Returns the list of buildable (or required) RelationshipManager object types for this object. More...
 
void checkParams (const std::string &parsing_syntax)
 This function checks parameters stored in the object to make sure they are in the correct state as the user expects: Required parameters are verified as valid meaning that they were either initialized when they were created, or were read from an input file or some other valid source. More...
 
void finalize (const std::string &parsing_syntax)
 Finalizes the parameters, which must be done before constructing any objects with these parameters (to be called in the corresponding factories). More...
 
std::filesystem::path getParamFileBase (const std::string &param_name) const
 
std::set< std::string >::const_iterator coupledVarsBegin () const
 Methods returning iterators to the coupled variables names stored in this InputParameters object. More...
 
std::set< std::string >::const_iterator coupledVarsEnd () const
 
const std::set< std::string > & getCoupledVariableParamNames () const
 Return the coupled variable parameter names. More...
 
const std::unordered_map< std::string, std::string > & getNewToDeprecatedVarMap () const
 Return the new to deprecated variable name map. More...
 
bool isRangeChecked (const std::string &param_name) const
 Return whether a parameter has a range check. More...
 
std::string rangeCheckedFunction (const std::string &name) const
 Return the range check function for any parameter (empty string if it is not range checked) More...
 
bool hasDefault (const std::string &param_name) const
 Return whether a parameter has a default. More...
 
bool hasCoupledValue (const std::string &coupling_name) const
 Return whether or not the coupled variable exists. More...
 
bool hasDefaultCoupledValue (const std::string &coupling_name) const
 Return whether or not the requested parameter has a default coupled value. More...
 
Real defaultCoupledValue (const std::string &coupling_name, unsigned int i=0) const
 Get the default value for an optionally coupled variable. More...
 
unsigned int numberDefaultCoupledValues (const std::string &coupling_name) const
 Get the number of defaulted coupled value entries. More...
 
void defaultCoupledValue (const std::string &coupling_name, Real value, unsigned int i=0)
 Set the default value for an optionally coupled variable (called by the Parser). More...
 
std::map< std::string, std::pair< std::string, std::string > > getAutoBuildVectors () const
 Returns the auto build vectors for all parameters. More...
 
void applyParameters (const InputParameters &common, const std::vector< std::string > &exclude={}, const bool allow_private=false)
 Method for applying common parameters. More...
 
void applySpecificParameters (const InputParameters &common, const std::vector< std::string > &include, bool allow_private=false)
 Method for applying common parameters. More...
 
void applyParameter (const InputParameters &common, const std::string &common_name, bool allow_private=false)
 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 by the user. More...
 
template<typename R1 , typename R2 , typename V1 = typename std::conditional<std::is_same<R1, MooseEnumItem>::value, MultiMooseEnum, std::vector<R1>>::type, typename V2 = typename std::conditional<std::is_same<R2, MooseEnumItem>::value, MultiMooseEnum, std::vector<R2>>::type>
std::vector< std::pair< R1, R2 > > get (const std::string &param1, const std::string &param2) const
 Combine two vector parameters into a single vector of pairs. More...
 
std::set< std::string > getParametersList () const
 
std::set< std::string > getControllableParameters () const
 Return list of controllable parameters. More...
 
std::set< std::string > getGroupParameters (const std::string &group) const
 Return names of parameters within a group. More...
 
void setReservedValues (const std::string &name, const std::set< std::string > &reserved)
 Provide a set of reserved values for a parameter. More...
 
std::set< std::string > reservedValues (const std::string &name) const
 Get a set of reserved parameter values. More...
 
std::string blockLocation () const
 
std::string blockFullpath () const
 
const hit::Node * getHitNode (const std::string &param) const
 
void setHitNode (const std::string &param, const hit::Node &node, const SetParamHitNodeKey)
 Sets the hit node associated with the parameter param to node. More...
 
std::string inputLocation (const std::string &param) const
 
std::string paramFullpath (const std::string &param) const
 
std::string errorPrefix (const std::string &param) const
 generate error message prefix with parameter name and location (if available) More...
 
std::string rawParamVal (const std::string &param) const
 
template<typename T >
void ignoreParameter (const std::string &name)
 Informs this object that values for this parameter set from the input file or from the command line should be ignored. More...
 
bool shouldIgnore (const std::string &name)
 Whether to ignore the value of an input parameter set in the input file or from the command line. More...
 
template<typename T >
bool isType (const std::string &name) const
 
std::string varName (const std::string &var_param_name, const std::string &moose_object_with_var_param_name) const
 Determine the actual variable name from the given variable parameter name. More...
 
void renameParam (const std::string &old_name, const std::string &new_name, const std::string &new_docstring)
 Rename a parameter and provide a new documentation string. More...
 
void renameCoupledVar (const std::string &old_name, const std::string &new_name, const std::string &new_docstring)
 Rename a coupled variable and provide a new documentation string. More...
 
void deprecateParam (const std::string &old_name, const std::string &new_name, const std::string &removal_date)
 
void deprecateCoupledVar (const std::string &old_name, const std::string &new_name, const std::string &removal_date)
 
std::string checkForRename (const std::string &name) const
 Checks whether the provided name is a renamed parameter name. More...
 
template<typename T >
const T & get (std::string_view name) const
 A wrapper around the Parameters base class method. More...
 
template<typename T >
bool have_parameter (std::string_view name) const
 A wrapper around the Parameters base class method. More...
 
template<typename T >
void transferParam (const InputParameters &source_param, const std::string &name, const std::string &new_name="", const std::string &new_description="")
 A routine to transfer a parameter from one class' validParams to another. More...
 
std::vector< std::string > paramAliases (const std::string &param_name) const
 Return all the aliased names associated with param_name. More...
 
const hit::Node * getHitNode () const
 
void setHitNode (const hit::Node &node, const SetHitNodeKey)
 Sets the hit node that represents the syntax responsible for creating these parameters. More...
 
bool isFinalized () const
 
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 &name, const std::string &doc_string, const std::string &deprecation_message)
 
template<>
void addDeprecatedParam (const std::string &name, const std::string &doc_string, const std::string &deprecation_message)
 
template<>
const MooseEnumgetParamHelper (const std::string &name, const InputParameters &pars, const MooseEnum *, const MooseBase *moose_base)
 
template<>
const MultiMooseEnumgetParamHelper (const std::string &name, const InputParameters &pars, const MultiMooseEnum *, const MooseBase *moose_base)
 
template<>
void addRequiredParam (const std::string &name, const MooseEnum &moose_enum, const std::string &doc_string)
 
template<>
void addRequiredParam (const std::string &name, const MultiMooseEnum &moose_enum, const std::string &doc_string)
 
template<>
void addParam (const std::string &, const std::string &)
 
template<>
void addParam (const std::string &, const std::string &)
 
template<>
void addPrivateParam (const std::string &)
 
template<>
void addPrivateParam (const std::string &)
 
template<>
void addDeprecatedParam (const std::string &, const std::string &, const std::string &)
 
template<>
void addDeprecatedParam (const std::string &, const std::string &, const std::string &)
 
template<>
const MooseEnumgetParamHelper (const std::string &name_in, const InputParameters &pars, const MooseEnum *, const MooseBase *)
 
template<>
const MultiMooseEnumgetParamHelper (const std::string &name_in, const InputParameters &pars, const MultiMooseEnum *, const MooseBase *)
 
template<typename T , typename S >
void addParam (const std::string &name, const S &value, const std::string &doc_string)
 These methods add an option 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
 
InputParametersoperator= (const InputParameters &rhs)
 
InputParametersoperator+= (const InputParameters &rhs)
 

Static Public Member Functions

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

Private Member Functions

 InputParameters ()
 
void setParameters ()
 Method to terminate the recursive setParameters definition. More...
 
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)
 
Metadataat (const std::string &param_name)
 
const Metadataat (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...
 
const CommandLineMetadatagetCommandLineMetadata (const std::string &name) const
 
template<typename T >
void addCommandLineParamHelper (const std::string &name, const std::string &syntax)
 Helper for all of the addCommandLineParam() calls, which sets up _cl_data in the metadata. More...
 
template<>
void setParamHelper (const std::string &name, PostprocessorName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &name, PostprocessorName &l_value, const int &r_value)
 
template<>
void setParamHelper (const std::string &, FunctionName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &, FunctionName &l_value, const int &r_value)
 
template<>
void setParamHelper (const std::string &, MaterialPropertyName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &, MaterialPropertyName &l_value, const int &r_value)
 
template<>
void setParamHelper (const std::string &, MooseFunctorName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &, MooseFunctorName &l_value, const int &r_value)
 
template<>
void setParamHelper (const std::string &, PostprocessorName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &, PostprocessorName &l_value, const int &r_value)
 
template<>
void setParamHelper (const std::string &, FunctionName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &, FunctionName &l_value, const int &r_value)
 
template<>
void setParamHelper (const std::string &, MaterialPropertyName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &, MaterialPropertyName &l_value, const int &r_value)
 
template<>
void setParamHelper (const std::string &, MooseFunctorName &l_value, const Real &r_value)
 
template<>
void setParamHelper (const std::string &, MooseFunctorName &l_value, const int &r_value)
 

Static Private Member Functions

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

Private Attributes

std::string _block_location
 original location of input block (i.e. filename,linenum) - used for nice error messages. More...
 
std::string _block_fullpath
 full HIT path of the block from the input file - used for nice error messages. More...
 
std::map< std::string, Metadata_params
 The actual parameter data. More...
 
std::set< std::string > _coupled_vars
 The coupled variables set. More...
 
std::string _class_description
 The class description for the owning object. More...
 
std::vector< std::string > _buildable_types
 The parameter is used to restrict types that can be built. More...
 
std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > _buildable_rm_types
 The RelationshipManagers that this object may either build or require. More...
 
bool _collapse_nesting
 This parameter collapses one level of nesting in the syntax blocks. More...
 
bool _moose_object_syntax_visibility
 This parameter hides derived MOOSE object types from appearing in syntax dumps. More...
 
bool _show_deprecated_message
 Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping messages. More...
 
bool _allow_copy
 A flag for toggling the error message in the copy constructor. More...
 
std::unordered_map< std::string, std::string > _new_to_deprecated_coupled_vars
 A map from deprecated coupled variable names to the new blessed name. More...
 
std::map< std::string, std::pair< std::string, std::string > > _old_to_new_name_and_dep
 A map from base-class/deprecated parameter names to derived-class/blessed parameter names and the deprecation messages in the case that the "old" parameter name is a deprecated parameter name. More...
 
std::multimap< std::string, std::string > _new_to_old_names
 A map from derived-class/blessed parameter names to associated base-class/deprecated parameter names. More...
 
const hit::Node * _hit_node
 The hit node representing the syntax that created these parameters, if any. More...
 
bool _finalized
 Whether or not we've called finalize() on these parameters yet. More...
 

Friends

class InputParameterWarehouse
 
class Parser
 
class ActionWarehouse
 
InputParameters emptyInputParameters ()
 

Detailed Description

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

Definition at line 63 of file InputParameters.h.

Constructor & Destructor Documentation

◆ InputParameters() [1/3]

InputParameters::InputParameters ( const InputParameters rhs)

Definition at line 47 of file InputParameters.C.

48  : Parameters(), _show_deprecated_message(true), _allow_copy(true)
49 {
50  *this = rhs;
51 }
bool _allow_copy
A flag for toggling the error message in the copy constructor.
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...

◆ InputParameters() [2/3]

InputParameters::InputParameters ( const Parameters &  rhs)

Definition at line 53 of file InputParameters.C.

55 {
56  _params.clear();
58  _collapse_nesting = false;
60 }
bool _allow_copy
A flag for toggling the error message in the copy constructor.
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
bool _collapse_nesting
This parameter collapses one level of nesting in the syntax blocks.
infix_ostream_iterator< T, charT, traits > & operator=(T const &item)
Definition: InfixIterator.h:46
bool _moose_object_syntax_visibility
This parameter hides derived MOOSE object types from appearing in syntax dumps.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ ~InputParameters()

virtual InputParameters::~InputParameters ( )
virtualdefault

◆ InputParameters() [3/3]

InputParameters::InputParameters ( )
private

Definition at line 36 of file InputParameters.C.

37  : Parameters(),
38  _collapse_nesting(false),
41  _allow_copy(true),
42  _hit_node(nullptr),
43  _finalized(false)
44 {
45 }
bool _allow_copy
A flag for toggling the error message in the copy constructor.
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
bool _collapse_nesting
This parameter collapses one level of nesting in the syntax blocks.
bool _finalized
Whether or not we&#39;ve called finalize() on these parameters yet.
const hit::Node * _hit_node
The hit node representing the syntax that created these parameters, if any.
bool _moose_object_syntax_visibility
This parameter hides derived MOOSE object types from appearing in syntax dumps.

Member Function Documentation

◆ addClassDescription()

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

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

Definition at line 82 of file InputParameters.C.

Referenced by FVDiffusionInterface::validParams(), FVOneVarDiffusionInterface::validParams(), FVTwoVarContinuityConstraint::validParams(), AddBCAction::validParams(), AddConstraintAction::validParams(), SetupMeshCompleteAction::validParams(), AverageNodalVariableValue::validParams(), ElementArrayL2Norm::validParams(), AddFunctorMaterialAction::validParams(), FVScalarLagrangeMultiplierInterface::validParams(), FVAdvection::validParams(), AddFVInitialConditionAction::validParams(), AddPostprocessorAction::validParams(), FVFunctorTimeKernel::validParams(), EmptyPostprocessor::validParams(), FVMatAdvection::validParams(), FVReaction::validParams(), ArrayVariableComponent::validParams(), FVTimeKernel::validParams(), ADRobinBC::validParams(), AddScalarKernelAction::validParams(), ArrayVarReductionAux::validParams(), NumElems::validParams(), NumLinearIterations::validParams(), NumNodes::validParams(), BuildArrayVariableAux::validParams(), NumRelationshipManagers::validParams(), NumVars::validParams(), ADVectorRobinBC::validParams(), PerfGraphData::validParams(), ArrayHFEMDirichletBC::validParams(), AnalyticalIndicator::validParams(), GradientJumpIndicator::validParams(), Residual::validParams(), LaplacianJumpIndicator::validParams(), ArrayNeumannBC::validParams(), ValueJumpIndicator::validParams(), ArrayPenaltyDirichletBC::validParams(), AddDamperAction::validParams(), AddFVInterfaceKernelAction::validParams(), ArrayVacuumBC::validParams(), ADTimeDerivative::validParams(), TimestepSize::validParams(), VariableResidual::validParams(), VectorPostprocessorComponent::validParams(), ADVectorDiffusion::validParams(), VectorPostprocessorReductionValue::validParams(), ADVectorTimeDerivative::validParams(), ArrayDiffusion::validParams(), ArrayReaction::validParams(), ExternalProblem::validParams(), ArrayTimeDerivative::validParams(), ConstantReporter::validParams(), ElementVariableStatistics::validParams(), NodalVariableStatistics::validParams(), AddTransferAction::validParams(), MassEigenKernel::validParams(), ADScalarTimeDerivative::validParams(), CoupledODETimeDerivative::validParams(), ODETimeDerivative::validParams(), MassLumpedTimeDerivative::validParams(), AddUserObjectAction::validParams(), ElementIntegerAux::validParams(), HFEMDirichletBC::validParams(), AddDGKernelAction::validParams(), AddIndicatorAction::validParams(), AddVectorPostprocessorAction::validParams(), ConstantDT::validParams(), TimeDerivative::validParams(), TestSourceStepper::validParams(), CheckFVBCAction::validParams(), VectorTimeDerivative::validParams(), AddInitialConditionAction::validParams(), ExtraElementIDAux::validParams(), ErrorFractionMarker::validParams(), ErrorToleranceMarker::validParams(), UniformMarker::validParams(), ValueRangeMarker::validParams(), ValueThresholdMarker::validParams(), GenericConstant2DArray::validParams(), AddBoundsVectorsAction::validParams(), AddDiracKernelAction::validParams(), AddInterfaceKernelAction::validParams(), CopyNodalVarsAction::validParams(), GenericConstantArray::validParams(), EqualValueBoundaryConstraint::validParams(), ConstantVectorPostprocessor::validParams(), AddKernelAction::validParams(), FileMesh::validParams(), CreateExecutionerAction::validParams(), TiledMesh::validParams(), AddMarkerAction::validParams(), BoundaryDeletionGenerator::validParams(), AddMaterialAction::validParams(), DynamicObjectRegistrationAction::validParams(), ArrayHFEMDiffusion::validParams(), DGConvection::validParams(), AddElementalFieldAction::validParams(), AddMeshGeneratorAction::validParams(), ElementIDOutputAction::validParams(), HFEMDiffusion::validParams(), GlobalParamsAction::validParams(), InversePowerMethod::validParams(), AddMultiAppAction::validParams(), PartitionerAction::validParams(), ProcessorIDAux::validParams(), AddNodalKernelAction::validParams(), ReadExecutorParamsAction::validParams(), PenaltyDirichletNodalKernel::validParams(), JSONOutput::validParams(), XMLOutput::validParams(), ExtraIDIntegralReporter::validParams(), CoefReactionTempl< is_ad >::validParams(), DerivativeSumMaterialTempl< is_ad >::validParams(), GenericConstantVectorMaterialTempl< is_ad >::validParams(), VerifyElementUniqueID::validParams(), VerifyNodalUniqueID::validParams(), LineValueSampler::validParams(), PointValueSampler::validParams(), SideValueSampler::validParams(), CreateProblemAction::validParams(), AddFieldSplitAction::validParams(), PeriodicFunction::validParams(), SetupMeshAction::validParams(), FVPostprocessorDirichletBC::validParams(), ElementExtremeMaterialPropertyTempl< is_ad >::validParams(), ElementExtremeValue::validParams(), ElementL2Error::validParams(), ArrayFunctionIC::validParams(), NodalExtremeValue::validParams(), FunctionScalarIC::validParams(), AddFVBCAction::validParams(), SideExtremeValue::validParams(), TimeExtremeValue::validParams(), ArrayBodyForce::validParams(), AddFVKernelAction::validParams(), LogConstantDT::validParams(), BoxMarker::validParams(), ActivateElementsUserObjectBase::validParams(), ElementQualityChecker::validParams(), ElementSubdomainModifier::validParams(), CSVReaderVectorPostprocessor::validParams(), Eigenvalues::validParams(), GapValueAux::validParams(), ADDGKernel::validParams(), OverlayMeshGenerator::validParams(), AdaptivityAction::validParams(), NodalPatchRecoveryAuxBase::validParams(), MooseObjectAction::validParams(), PenetrationAux::validParams(), UniqueExtraIDMeshGenerator::validParams(), SetupDebugAction::validParams(), AddFunctionAction::validParams(), SetupPreconditionerAction::validParams(), TimeDerivativeAux::validParams(), FVFunctorDirichletBCTempl< is_ad >::validParams(), SidesetInfoVectorPostprocessor::validParams(), SetupPredictorAction::validParams(), AverageElementSize::validParams(), AreaPostprocessor::validParams(), ConstantPostprocessor::validParams(), AddPositionsAction::validParams(), SetupTimeIntegratorAction::validParams(), ElementAverageSecondTimeDerivative::validParams(), ElementAverageTimeDerivative::validParams(), ElementExtremeFunctorValueTempl< is_ad >::validParams(), VectorVariableMagnitudeAux::validParams(), VolumeAux::validParams(), FVCoupledForce::validParams(), SetupTimeStepperAction::validParams(), ElementL2Difference::validParams(), WeightedGapAux::validParams(), AdvectiveFluxAux::validParams(), FunctionElementAverage::validParams(), FunctionElementIntegral::validParams(), FunctionSideAverage::validParams(), NodalL2Error::validParams(), NodalMaxValueId::validParams(), NodalSum::validParams(), AddReporterAction::validParams(), ElementsAlongLine::validParams(), ScalarComponentIC::validParams(), ADVectorMatchedValueBC::validParams(), NumResidualEvaluations::validParams(), ConstantAux::validParams(), ScalarVariable::validParams(), ScalePostprocessor::validParams(), ConstantScalarAux::validParams(), InterfaceDiffusion::validParams(), CopyValueAux::validParams(), TimeIntegratedPostprocessor::validParams(), TimePostprocessor::validParams(), AddTimesAction::validParams(), VolumePostprocessor::validParams(), SingleMatrixPreconditioner::validParams(), DebugResidualAux::validParams(), ArrayCoupledTimeDerivative::validParams(), AddTimeStepperAction::validParams(), RestartableDataReporter::validParams(), CoupledTimeDerivative::validParams(), DivField::validParams(), NullScalarKernel::validParams(), GradField::validParams(), FunctionDiffusion::validParams(), ExplicitEuler::validParams(), FunctorDirichletBC::validParams(), MassMatrix::validParams(), ExplicitSSPRungeKutta::validParams(), FunctorNeumannBC::validParams(), ImplicitEuler::validParams(), MaterialDerivativeTestKernel::validParams(), TimeIntervalTimes::validParams(), NullKernel::validParams(), VectorCoupledTimeDerivative::validParams(), MultiAppCloneReporterTransfer::validParams(), MultiAppReporterTransfer::validParams(), BoundaryMarker::validParams(), InterfaceQpMaterialPropertyRealUO::validParams(), ComboMarker::validParams(), ElemSideNeighborLayersGeomTester::validParams(), ForcingFunctionAux::validParams(), ElemSideNeighborLayersTester::validParams(), GeometrySphere::validParams(), FunctionArrayAux::validParams(), InterfaceQpValueUserObject::validParams(), JSONFileReader::validParams(), ComposeTimeStepperAction::validParams(), VariableOldValueBounds::validParams(), AnnularMesh::validParams(), ElementsAlongPlane::validParams(), GeneratedMesh::validParams(), IntersectionPointsAlongLine::validParams(), LineFunctionSampler::validParams(), RinglebMesh::validParams(), SpiralAnnularMesh::validParams(), ExtraElementIntegerDivision::validParams(), NestedDivision::validParams(), AddDistributionAction::validParams(), AddMetaDataGenerator::validParams(), BlockDeletionGenerator::validParams(), BlockToMeshConverterGenerator::validParams(), DeprecatedBlockAction::validParams(), BreakBoundaryOnSubdomainGenerator::validParams(), BreakMeshByBlockGeneratorBase::validParams(), CoarsenBlockGenerator::validParams(), ElementGenerator::validParams(), ElementsToTetrahedronsConverter::validParams(), ExtraNodesetGenerator::validParams(), FileMeshGenerator::validParams(), FillBetweenCurvesGenerator::validParams(), ArrayDGDiffusion::validParams(), FillBetweenPointVectorsGenerator::validParams(), FillBetweenSidesetsGenerator::validParams(), FlipSidesetGenerator::validParams(), AddMeshDivisionAction::validParams(), LowerDBlockFromSidesetGenerator::validParams(), MoveNodeGenerator::validParams(), NodeSetsFromSideSetsGenerator::validParams(), FunctionDiracSource::validParams(), PlaneIDMeshGenerator::validParams(), RefineBlockGenerator::validParams(), RefineSidesetGenerator::validParams(), RenameBlockGenerator::validParams(), RenameBoundaryGenerator::validParams(), RinglebMeshGenerator::validParams(), SideSetsFromNodeSetsGenerator::validParams(), SideSetsFromNormalsGenerator::validParams(), SmoothMeshGenerator::validParams(), SphereMeshGenerator::validParams(), SpiralAnnularMeshGenerator::validParams(), ConstantFunction::validParams(), SubdomainIDGenerator::validParams(), SubdomainPerElementGenerator::validParams(), SymmetryTransformGenerator::validParams(), TiledMeshGenerator::validParams(), ProjectionAux::validParams(), PiecewiseConstant::validParams(), LowerBoundNodalKernel::validParams(), CoupledForceNodalKernel::validParams(), ReactionNodalKernel::validParams(), SecondTimeDerivativeAux::validParams(), UpperBoundNodalKernel::validParams(), FunctorADConverterTempl< T >::validParams(), GMVOutput::validParams(), SplineFunction::validParams(), FunctorSmootherTempl< T >::validParams(), PerfGraphOutput::validParams(), ReporterDebugOutput::validParams(), Tecplot::validParams(), VTKOutput::validParams(), XDA::validParams(), TagVectorArrayVariableValueAux::validParams(), FVBoundaryScalarLagrangeMultiplierConstraint::validParams(), DiffusionCG::validParams(), DiffusionFV::validParams(), FilePositions::validParams(), InputPositions::validParams(), MultiAppPositions::validParams(), ReporterPositions::validParams(), TransformedPositions::validParams(), VariableGradientComponent::validParams(), AxisymmetricCenterlineAverageValue::validParams(), ChangeOverTimePostprocessor::validParams(), ChangeOverFixedPointPostprocessor::validParams(), VectorMagnitudeAux::validParams(), ElementAverageMaterialPropertyTempl< is_ad >::validParams(), VectorPostprocessorVisualizationAux::validParams(), SphericalAverage::validParams(), VectorVariableComponentAux::validParams(), FVAnisotropicDiffusion::validParams(), SetupResidualDebugAction::validParams(), ElementL2FunctorErrorTempl< is_ad >::validParams(), ElementSidesL2Norm::validParams(), FVMassMatrix::validParams(), OldEqualValueConstraint::validParams(), ArrayParsedAux::validParams(), FVScalarLagrangeMultiplierConstraint::validParams(), NearestNodeNumber::validParams(), MeshGeneratorMesh::validParams(), NodalMaxValue::validParams(), NumFailedTimeSteps::validParams(), NumFixedPointIterations::validParams(), IntegralPreservingFunctionIC::validParams(), NumNonlinearIterations::validParams(), EqualValueConstraint::validParams(), ExtraIDIntegralVectorPostprocessor::validParams(), ParsedPostprocessor::validParams(), ElementValueSampler::validParams(), PseudoTimestep::validParams(), Receiver::validParams(), CylindricalAverage::validParams(), SideAverageMaterialPropertyTempl< is_ad >::validParams(), InterfaceReaction::validParams(), PenaltyInterfaceDiffusionTempl< T, is_ad >::validParams(), MessageFromInput::validParams(), ADConservativeAdvection::validParams(), ConvectiveFluxBC::validParams(), FiniteDifferencePreconditioner::validParams(), AccumulateReporter::validParams(), DiffusionFluxAux::validParams(), IterationInfo::validParams(), EigenDirichletBC::validParams(), ConservativeAdvection::validParams(), DivergenceAuxTempl< is_ad >::validParams(), Diffusion::validParams(), ParsedODEKernel::validParams(), ActuallyExplicitEuler::validParams(), BDF2::validParams(), MaterialDerivativeRankFourTestKernel::validParams(), NewmarkBeta::validParams(), MaterialDerivativeRankTwoTestKernel::validParams(), MatchedValueBCTempl< is_ad >::validParams(), ExodusFileTimes::validParams(), InputTimes::validParams(), ElementLengthAux::validParams(), SimulationTimes::validParams(), ReactionTempl< is_ad >::validParams(), ExodusTimeSequenceStepper::validParams(), FunctionDT::validParams(), PostprocessorDT::validParams(), TimeSequenceStepper::validParams(), MultiAppPostprocessorToAuxScalarTransfer::validParams(), MultiAppScalarToAuxScalarTransfer::validParams(), BoundaryPreservedMarker::validParams(), GeometryBase::validParams(), ReporterPointMarker::validParams(), InterfaceValueUserObject::validParams(), LayeredAverage::validParams(), LayeredSideAverageFunctor::validParams(), LayeredSideIntegralFunctor::validParams(), NearestNodeNumberUO::validParams(), FunctorAux::validParams(), ConstantBounds::validParams(), ProjectedStatefulMaterialNodalPatchRecoveryBase::validParams(), MaterialFunctorConverterTempl< T >::validParams(), VectorFromComponentVariablesMaterialTempl< is_ad >::validParams(), ReporterTimes::validParams(), EqualGradientConstraint::validParams(), ConcentricCircleMesh::validParams(), ImageMesh::validParams(), NodalValueSampler::validParams(), GhostingAux::validParams(), SpatialUserObjectVectorPostprocessor::validParams(), HardwareIDAux::validParams(), FunctorBinnedValuesDivision::validParams(), InterfaceValueUserObjectAux::validParams(), SubdomainsDivision::validParams(), PIDTransientControl::validParams(), AnnularMeshGenerator::validParams(), BreakMeshByBlockGenerator::validParams(), CartesianMeshGenerator::validParams(), MaxIncrement::validParams(), ADDGAdvection::validParams(), ConcentricCircleMeshGenerator::validParams(), CutMeshByPlaneGenerator::validParams(), MaterialRealDenseMatrixAux::validParams(), MaterialRealTensorValueAux::validParams(), MaterialStdVectorAuxTempl< is_ad >::validParams(), GeneratedMeshGenerator::validParams(), ImageSubdomainGenerator::validParams(), MaterialStdVectorRealGradientAux::validParams(), MeshDiagnosticsGenerator::validParams(), ConstantPointSource::validParams(), MeshRepairGenerator::validParams(), ParsedSubdomainMeshGenerator::validParams(), PatchMeshGenerator::validParams(), CSVFileTimes::validParams(), PolyLineMeshGenerator::validParams(), ParsedAux::validParams(), NullExecutor::validParams(), SideSetExtruderGenerator::validParams(), SideSetsBetweenSubdomainsGenerator::validParams(), ParsedVectorAux::validParams(), SideSetsFromPointsGenerator::validParams(), LinearCombinationFunction::validParams(), VectorDiffusion::validParams(), TransformGenerator::validParams(), CentroidMultiApp::validParams(), QuadraturePointMultiApp::validParams(), PiecewiseConstantFromCSV::validParams(), PiecewiseLinear::validParams(), PiecewiseLinearBase::validParams(), Console::validParams(), ControlOutput::validParams(), FVDirichletBC::validParams(), SpatialUserObjectAux::validParams(), ParsedFunctorMaterialTempl< is_ad >::validParams(), VectorMagnitudeFunctorMaterialTempl< is_ad >::validParams(), TagMatrixAux::validParams(), FVConstantScalarOutflowBC::validParams(), TagVectorArrayVariableAux::validParams(), TagVectorAux::validParams(), FVFunctionDirichletBC::validParams(), ElementCentroidPositions::validParams(), FunctorPositions::validParams(), FVNeumannBC::validParams(), WorkBalance::validParams(), VectorFunctionAux::validParams(), InterfaceQpMaterialPropertyBaseUserObject< Real >::validParams(), VectorPenaltyDirichletBC::validParams(), ReferenceResidualProblem::validParams(), ElementHCurlError::validParams(), ElementHCurlSemiError::validParams(), ElementHDivError::validParams(), ElementL1Error::validParams(), PositionsFunctorValueSampler::validParams(), ADDirichletBC::validParams(), FunctionSideIntegral::validParams(), ADFunctionDirichletBC::validParams(), ADFunctionNeumannBC::validParams(), InterfaceIntegralPostprocessor::validParams(), LineMaterialRealSampler::validParams(), SetAdaptivityOptionsAction::validParams(), MaterialVectorPostprocessor::validParams(), NodalL2Norm::validParams(), EqualValueEmbeddedConstraint::validParams(), ADVectorFunctionDirichletBC::validParams(), LeastSquaresFit::validParams(), ADVectorFunctionNeumannBC::validParams(), PercentChangePostprocessor::validParams(), ArrayDirichletBC::validParams(), RelativeSolutionDifferenceNorm::validParams(), FunctorVectorElementalAuxTempl< is_ad >::validParams(), MatDiffusion::validParams(), CoupledTiedValueConstraint::validParams(), ADMatCoupledForce::validParams(), ADMatReaction::validParams(), DirichletBC::validParams(), StitchBoundaryMeshGenerator::validParams(), EigenArrayDirichletBC::validParams(), NumMeshDivisions::validParams(), SolutionInvalidityReporter::validParams(), CoupledForceTempl< is_ad >::validParams(), FunctionGradientNeumannBC::validParams(), LayeredSideAverage::validParams(), LayeredSideDiffusiveFluxAverage::validParams(), NumPositions::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), NeumannBCTempl< is_ad >::validParams(), ElementLpNormAux::validParams(), SolutionTimeAdaptiveDT::validParams(), TimeSequenceFromTimes::validParams(), FunctionNeumannBC::validParams(), ElementQualityAux::validParams(), VectorFunctionReaction::validParams(), PostprocessorDirichletBC::validParams(), InterfaceUserObject::validParams(), MultiAppVariableValueSampleTransfer::validParams(), VectorDivPenaltyDirichletBC::validParams(), VectorFunctionDirichletBC::validParams(), VectorDirichletBC::validParams(), MemoryUsage::validParams(), ArrayConstantIC::validParams(), FunctionAux::validParams(), ParsedCurveGenerator::validParams(), FunctorTimes::validParams(), GenericConstantRankTwoTensorTempl< is_ad >::validParams(), GenericFunctionRankTwoTensorTempl< is_ad >::validParams(), NodalNormalsCorner::validParams(), NodalNormalsEvaluator::validParams(), FunctionScalarAux::validParams(), FunctorElementalGradientAuxTempl< is_ad >::validParams(), VectorCurlPenaltyDirichletBC::validParams(), ImageMeshGenerator::validParams(), DistributedPositions::validParams(), CreateDisplacedProblemAction::validParams(), MultiAppShapeEvaluationTransfer::validParams(), VariableValueVolumeHistogram::validParams(), CartesianGridDivision::validParams(), CylindricalGridDivision::validParams(), TiedValueConstraint::validParams(), BoolFunctionControl::validParams(), SphericalGridDivision::validParams(), ConditionalFunctionEnableControl::validParams(), AdvancedExtruderGenerator::validParams(), AllSideSetsByNormalsGenerator::validParams(), MaterialRateRealAuxTempl< is_ad >::validParams(), BoundingValueElementDamper::validParams(), BoundingValueNodalDamper::validParams(), BreakMeshByElementGenerator::validParams(), CircularBoundaryCorrectionGenerator::validParams(), CombinerGenerator::validParams(), ElementHDivSemiError::validParams(), MeshCollectionGenerator::validParams(), MeshExtruderGenerator::validParams(), MeshDivisionAux::validParams(), MultiAppGeneralFieldShapeEvaluationTransfer::validParams(), NearestNodeDistanceAux::validParams(), VectorConstantPointSource::validParams(), DifferencePostprocessor::validParams(), MaterialDerivativeTestAction::validParams(), NormalizationAux::validParams(), BicubicSplineFunction::validParams(), ElementGroupCentroidPositions::validParams(), CompositeFunction::validParams(), StackGenerator::validParams(), StitchedMeshGenerator::validParams(), VariableTimeIntegrationAux::validParams(), FullSolveMultiApp::validParams(), QuotientScalarAux::validParams(), ScalarTagMatrixAux::validParams(), ScalarTagVectorAux::validParams(), LayeredExtremumMaterialProperty::validParams(), FileOutput::validParams(), Gnuplot::validParams(), GenericFunctorGradientMaterialTempl< is_ad >::validParams(), SingleRankPartitioner::validParams(), GenericFunctorMaterialTempl< is_ad >::validParams(), SolutionHistory::validParams(), BlockWeightedPartitioner::validParams(), NodalPatchRecoveryMaterialProperty::validParams(), FVFunctorNeumannBC::validParams(), GenericVectorFunctorMaterialTempl< is_ad >::validParams(), VectorMemoryUsage::validParams(), CumulativeValuePostprocessor::validParams(), FunctionElementIntegralUserObject::validParams(), ElementIntegralMaterialPropertyTempl< is_ad >::validParams(), TimeDerivativeNodalKernel::validParams(), DOFMapOutput::validParams(), MeshDivisionFunctorReductionVectorPostprocessor::validParams(), FVOrthogonalDiffusion::validParams(), LeastSquaresFitHistory::validParams(), ConstantRate::validParams(), PointValue::validParams(), QuotientAux::validParams(), MultiAppPostprocessorInterpolationTransfer::validParams(), NearestNodeValueAux::validParams(), SideAverageValue::validParams(), XYMeshLineCutter::validParams(), CoupledValueFunctionMaterialTempl< is_ad >::validParams(), AnisotropicDiffusion::validParams(), LayeredIntegral::validParams(), PiecewiseLinearInterpolationMaterial::validParams(), NearestPointLayeredSideAverageFunctor::validParams(), CoarsenedPiecewiseLinear::validParams(), OneDEqualValueConstraintBC::validParams(), FEProblem::validParams(), MatCoupledForce::validParams(), VectorOfPostprocessors::validParams(), ParsedNodeTransformGenerator::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), MultiAppPostprocessorTransfer::validParams(), CentralDifference::validParams(), MultiAppVectorPostprocessorTransfer::validParams(), PerfGraphReporter::validParams(), PointwiseRenormalizeVector::validParams(), CreateApplicationBlockAction::validParams(), GreaterThanLessThanPostprocessor::validParams(), MatNeumannBCTempl< is_ad >::validParams(), InterfaceAverageVariableValuePostprocessor::validParams(), DisplayGhostingAction::validParams(), ConstantDamper::validParams(), OrientedSubdomainBoundingBoxGenerator::validParams(), ElementAverageValue::validParams(), NearestPositionsDivision::validParams(), MultiAppVariableValueSamplePostprocessorTransfer::validParams(), FunctionDirichletBC::validParams(), SetupQuadratureAction::validParams(), MaterialPropertyValueTempl< is_ad >::validParams(), XYDelaunayGenerator::validParams(), NearestPointLayeredSideIntegralFunctor::validParams(), LayeredSideIntegral::validParams(), PiecewiseLinearFromVectorPostprocessor::validParams(), CSV::validParams(), FVFunctionNeumannBC::validParams(), RandomPartitioner::validParams(), FVDirichletBCBase::validParams(), MaterialADConverterTempl< T >::validParams(), AddOutputAction::validParams(), FVBodyForce::validParams(), ADPiecewiseLinearInterpolationMaterial::validParams(), ElementIntegralFunctorPostprocessorTempl< is_ad >::validParams(), LinearNodalConstraint::validParams(), InterpolatedStatefulMaterialTempl< T >::validParams(), FunctionValuePostprocessor::validParams(), NumDOFs::validParams(), VectorNeumannBC::validParams(), AddAuxVariableAction::validParams(), InterfacePostprocessor::validParams(), EigenProblem::validParams(), ElementH1SemiError::validParams(), ElementH1ErrorFunctionAux::validParams(), AddSamplerAction::validParams(), ParsedGenerateSideset::validParams(), FunctionLayeredIntegral::validParams(), ParsedMaterialTempl< is_ad >::validParams(), MaterialDerivativeTestKernelBase< Real >::validParams(), VectorBodyForce::validParams(), ElementUOAux::validParams(), SideIntegralMaterialPropertyTempl< is_ad >::validParams(), MaterialRankFourTensorAux::validParams(), ElementVectorL2Error::validParams(), ReporterPointSource::validParams(), ElementH1Error::validParams(), ADConservativeAdvectionBC::validParams(), DerivativeParsedMaterialTempl< is_ad >::validParams(), ElementIntegralVariableUserObject::validParams(), SolutionAux::validParams(), SolutionScalarAux::validParams(), FVBoundaryIntegralValueConstraint::validParams(), PetscExternalPartitioner::validParams(), DiffusionPhysicsBase::validParams(), NodalEqualValueConstraint::validParams(), ElementIntegralArrayVariablePostprocessor::validParams(), FVDivergence::validParams(), InterfaceQpUserObjectBase::validParams(), UserForcingFunctionNodalKernel::validParams(), PostprocessorNeumannBC::validParams(), MultiAppDofCopyTransfer::validParams(), ElementL2ErrorFunctionAux::validParams(), NearestPointAverage::validParams(), NearestPointIntegralVariablePostprocessor::validParams(), SideSetsAroundSubdomainGenerator::validParams(), ElementalVariableValue::validParams(), CrankNicolson::validParams(), ElementIntegralUserObject::validParams(), TransfiniteMeshGenerator::validParams(), MatReaction::validParams(), LibtorchControlValuePostprocessor::validParams(), TimePeriod::validParams(), ScalarConstantIC::validParams(), BoundingBoxIC::validParams(), TimePeriodBase::validParams(), FindValueOnLine::validParams(), PlaneDeletionGenerator::validParams(), MultiAppGeneralFieldNearestLocationTransfer::validParams(), ElementIntegralVariablePostprocessor::validParams(), SideIntegralFunctorPostprocessorTempl< is_ad >::validParams(), MaterialPropertyDebugOutput::validParams(), TransientMultiApp::validParams(), TagVectorSum::validParams(), OrientedBoxMarker::validParams(), CoupledVarNeumannBCTempl< false >::validParams(), ScalarL2Error::validParams(), ImageFunction::validParams(), ElementVariablesDifferenceMax::validParams(), ContainsPointAux::validParams(), CSVTimeSequenceStepper::validParams(), FieldSplitPreconditioner::validParams(), LibtorchArtificialNeuralNetParameters::validParams(), MultiAppProjectionTransfer::validParams(), MultiAppCopyTransfer::validParams(), FVOrthogonalBoundaryDiffusion::validParams(), StitchedMesh::validParams(), GenericConstantMaterialTempl< is_ad >::validParams(), RealFunctionControl::validParams(), PNGOutput::validParams(), VariableResidualNormsDebugOutput::validParams(), ADMatDiffusionBase< Real >::validParams(), Exodus::validParams(), VacuumBC::validParams(), LibmeshPartitioner::validParams(), DGDiffusion::validParams(), PiecewiseMulticonstant::validParams(), LinearCombinationPostprocessor::validParams(), Nemesis::validParams(), FVConstantIC::validParams(), NearestPointLayeredSideIntegral::validParams(), HistogramVectorPostprocessor::validParams(), MeshInfo::validParams(), MooseParsedVectorFunction::validParams(), PhysicsBase::validParams(), SideIntegralVariablePostprocessor::validParams(), MultiAppNearestNodeTransfer::validParams(), MaterialRealAuxTempl< is_ad >::validParams(), ADDGDiffusion::validParams(), FVDiffusion::validParams(), PiecewiseMultilinear::validParams(), InterfaceIntegralVariableValuePostprocessor::validParams(), PenaltyEqualValueConstraintTempl< is_ad >::validParams(), BodyForceTempl< is_ad >::validParams(), AddPeriodicBCAction::validParams(), AdamsPredictor::validParams(), PatternedMeshGenerator::validParams(), NearestPointLayeredSideDiffusiveFluxAverage::validParams(), NodalVariableValue::validParams(), NearestPointLayeredIntegral::validParams(), InternalSideIntegralVariablePostprocessor::validParams(), Heun::validParams(), ParsedElementDeletionGenerator::validParams(), Split::validParams(), ExplicitMidpoint::validParams(), Ralston::validParams(), LibtorchNeuralNetControl::validParams(), SubdomainBoundingBoxGenerator::validParams(), SinDirichletBC::validParams(), NearestPointLayeredAverage::validParams(), AddControlAction::validParams(), NearestPointLayeredSideAverage::validParams(), MaterialRealVectorValueAuxTempl< is_ad >::validParams(), SinNeumannBC::validParams(), WeakGradientBC::validParams(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::validParams(), EigenExecutionerBase::validParams(), NodalNormalsPreprocessor::validParams(), SideAdvectiveFluxIntegralTempl< is_ad >::validParams(), ADFunctionPenaltyDirichletBC::validParams(), NearestRadiusLayeredAverage::validParams(), DiffusionFluxBC::validParams(), FVFunctionIC::validParams(), GhostingUserObject::validParams(), DistributedRectilinearMeshGenerator::validParams(), FunctionIC::validParams(), HFEMTestJump::validParams(), VectorConstantIC::validParams(), AddNodalNormalsAction::validParams(), HFEMTrialJump::validParams(), CommonOutputAction::validParams(), Axisymmetric2D3DSolutionFunction::validParams(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::validParams(), MaterialRankTwoTensorAuxTempl< is_ad >::validParams(), FunctionPenaltyDirichletBC::validParams(), DumpObjectsProblem::validParams(), PropertyReadFile::validParams(), FVIntegralValueConstraint::validParams(), BoundingBoxNodeSetGenerator::validParams(), MooseParsedGradFunction::validParams(), FVBoundedValueConstraint::validParams(), VectorFunctionIC::validParams(), MultiAppUserObjectTransfer::validParams(), GenericFunctionMaterialTempl< is_ad >::validParams(), MooseParsedFunction::validParams(), MultiAppGeometricInterpolationTransfer::validParams(), DGFunctionDiffusionDirichletBC::validParams(), ProjectedStatefulMaterialStorageAction::validParams(), GenericFunctionVectorMaterialTempl< is_ad >::validParams(), PatternedMesh::validParams(), GridPartitioner::validParams(), AB2PredictorCorrector::validParams(), FVPointValueConstraint::validParams(), InterfaceUserObjectBase::validParams(), ADPeriodicSegmentalConstraint::validParams(), PostprocessorComparison::validParams(), PeriodicSegmentalConstraint::validParams(), SolutionUserObject::validParams(), ADPenaltyPeriodicSegmentalConstraint::validParams(), PenaltyPeriodicSegmentalConstraint::validParams(), ConstantIC::validParams(), PhysicsBasedPreconditioner::validParams(), ScalarSolutionIC::validParams(), ElementW1pError::validParams(), AverageValueConstraint::validParams(), RelativeDifferencePostprocessor::validParams(), VectorPostprocessorComparison::validParams(), ScalarLagrangeMultiplier::validParams(), Transient::validParams(), IterationAdaptiveDT::validParams(), PostprocessorSpatialUserObject::validParams(), RadialAverage::validParams(), FunctionMaterialBase< is_ad >::validParams(), VariableCondensationPreconditioner::validParams(), ScalarLMKernelTempl< is_ad >::validParams(), Steady::validParams(), PenaltyDirichletBC::validParams(), CompositionDT::validParams(), ADPenaltyDirichletBC::validParams(), DisplacedProblem::validParams(), Eigenvalue::validParams(), SimplePredictor::validParams(), SolutionIC::validParams(), RandomIC::validParams(), DerivativeParsedMaterialHelperTempl< is_ad >::validParams(), LStableDirk2::validParams(), Terminator::validParams(), RandomICBase::validParams(), MooseVariableBase::validParams(), MeshDivision::validParams(), LStableDirk3::validParams(), ImplicitMidpoint::validParams(), DerivativeFunctionMaterialBaseTempl< is_ad >::validParams(), OutputInterface::validParams(), ExplicitTVDRK2::validParams(), PiecewiseBilinear::validParams(), LStableDirk4::validParams(), AStableDirk4::validParams(), Sampler::validParams(), ParsedMaterialHelper< is_ad >::validParams(), Checkpoint::validParams(), and TopResidualDebugOutput::validParams().

83 {
84  _class_description = doc_string;
85 }
std::string _class_description
The class description for the owning object.

◆ addCommandLineParam() [1/2]

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

Definition at line 1689 of file InputParameters.h.

Referenced by MooseApp::addAppParam(), Moose::addMainCommandLineParams(), and MooseApp::validParams().

1692 {
1693  addParam<T>(name, doc_string);
1694  addCommandLineParamHelper<T>(name, syntax);
1695 }
std::string name(const ElemQuality q)

◆ addCommandLineParam() [2/2]

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

1703 {
1704  addParam<T>(name, value, doc_string);
1705  addCommandLineParamHelper<T>(name, syntax);
1706 }
std::string name(const ElemQuality q)
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ addCommandLineParamHelper()

template<typename T >
void InputParameters::addCommandLineParamHelper ( const std::string &  name,
const std::string &  syntax 
)
private

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

Definition at line 1562 of file InputParameters.h.

1563 {
1564  auto & cl_data = at(name)._cl_data;
1565  cl_data = CommandLineMetadata();
1566  MooseUtils::tokenize(syntax, cl_data->syntax, 1, " \t\n\v\f\r");
1567  if constexpr (std::is_same_v<T, bool>)
1568  cl_data->argument_type = CommandLineMetadata::ArgumentType::NONE;
1569  else if constexpr (std::is_same_v<T, MooseEnum>)
1570  cl_data->argument_type = CommandLineMetadata::ArgumentType::REQUIRED;
1571  else
1572  cl_data->argument_type = CommandLineMetadata::ArgumentType::OPTIONAL;
1573 }
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
Definition: MooseUtils.h:779
std::optional< CommandLineMetadata > _cl_data
The data pertaining to a command line parameter (empty if not a command line param) ...
Metadata & at(const std::string &param_name)

◆ addCoupledVar() [1/3]

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

This method adds a coupled variable name pair.

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

Definition at line 257 of file InputParameters.C.

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

258 {
259  addParam<std::vector<VariableName>>(name, doc_string);
260  _coupled_vars.insert(name);
261 
262  // Set the doc string for any associated deprecated coupled var
263  setDeprecatedVarDocString(name, doc_string);
264 }
std::string name(const ElemQuality q)
void setDeprecatedVarDocString(const std::string &new_name, const std::string &doc_string)
Private method for setting deprecated coupled variable documentation strings.
std::set< std::string > _coupled_vars
The coupled variables set.

◆ addCoupledVar() [2/3]

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

This method adds a coupled variable name pair.

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

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

Definition at line 228 of file InputParameters.C.

229 {
230  addParam<std::vector<VariableName>>(name, doc_string);
231  _coupled_vars.insert(name);
232  auto & metadata = _params[name];
233  metadata._coupled_default.assign(1, value);
234  metadata._have_coupled_default = true;
235 
236  // Set the doc string for any associated deprecated coupled var
237  setDeprecatedVarDocString(name, doc_string);
238 }
std::string name(const ElemQuality q)
void setDeprecatedVarDocString(const std::string &new_name, const std::string &doc_string)
Private method for setting deprecated coupled variable documentation strings.
std::set< std::string > _coupled_vars
The coupled variables set.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ addCoupledVar() [3/3]

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

This method adds a coupled variable name pair.

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

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

Definition at line 241 of file InputParameters.C.

244 {
245  // std::vector<VariableName>(1, Moose::stringify(value)),
246  addParam<std::vector<VariableName>>(name, doc_string);
247  _coupled_vars.insert(name);
248  auto & metadata = _params[name];
249  metadata._coupled_default = value;
250  metadata._have_coupled_default = true;
251 
252  // Set the doc string for any associated deprecated coupled var
253  setDeprecatedVarDocString(name, doc_string);
254 }
std::string name(const ElemQuality q)
void setDeprecatedVarDocString(const std::string &new_name, const std::string &doc_string)
Private method for setting deprecated coupled variable documentation strings.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::set< std::string > _coupled_vars
The coupled variables set.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ addCoupledVarWithAutoBuild()

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

These methods add a coupled variable name pair.

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

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

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

Definition at line 295 of file InputParameters.C.

Referenced by addRequiredCoupledVarWithAutoBuild().

299 {
300  addParam<std::vector<VariableName>>(name, doc_string);
301  _coupled_vars.insert(name);
302  _params[name]._autobuild_vecs = std::make_pair(base_name, num_name);
303 
304  // Additionally there are two more parameters that need to be added:
305  addParam<std::string>(base_name, doc_string + " (base_name)");
306  addParam<unsigned int>(num_name, doc_string + " (num_name)");
307 }
std::string name(const ElemQuality q)
std::set< std::string > _coupled_vars
The coupled variables set.
std::map< std::string, Metadata > _params
The actual parameter data.

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

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

1622 {
1623  addParam<T>(name, value, doc_string);
1624  _params[name]._custom_type = custom_type;
1625 }
std::string name(const ElemQuality q)
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::map< std::string, Metadata > _params
The actual parameter data.

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

1632 {
1633  addParam<T>(name, doc_string);
1634  _params[name]._custom_type = custom_type;
1635 }
std::string name(const ElemQuality q)
std::map< std::string, Metadata > _params
The actual parameter data.

◆ addDeprecatedCoupledVar()

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

This method adds a deprecated coupled variable name pair.

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

Definition at line 267 of file InputParameters.C.

270 {
271  mooseDeprecated("Please use 'deprecateCoupledVar'");
272 
273  _show_deprecated_message = false;
274 
275  // Set the doc string if we are adding the deprecated var after the new var has already been added
276  auto params_it = _params.find(new_name);
277  std::string doc_string;
278  if (params_it != _params.end())
279  doc_string = params_it->second._doc_string;
280 
281  addParam<std::vector<VariableName>>(old_name, doc_string);
282  _coupled_vars.insert(old_name);
283  _new_to_deprecated_coupled_vars.emplace(new_name, old_name);
284 
285  std::string deprecation_message =
286  "The coupled variable parameter '" + old_name + "' has been deprecated";
287  if (!removal_date.empty())
288  deprecation_message += " and will be removed " + removal_date;
289  deprecation_message += ". Please use the '" + new_name + "' coupled variable parameter instead.";
290  _params[old_name]._deprecation_message = deprecation_message;
292 }
std::unordered_map< std::string, std::string > _new_to_deprecated_coupled_vars
A map from deprecated coupled variable names to the new blessed name.
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:313
std::set< std::string > _coupled_vars
The coupled variables set.
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an option parameter and a documentation string to the InputParameters object...
std::map< std::string, Metadata > _params
The actual parameter data.

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

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

1643 {
1644  _show_deprecated_message = false;
1645  addParam<T>(name, doc_string);
1646  auto & metadata = _params[name];
1647  metadata._custom_type = custom_type;
1648 
1649  metadata._deprecation_message = deprecation_message;
1650  _show_deprecated_message = true;
1651 }
std::string name(const ElemQuality q)
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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
nameThe name of the parameter
valueThe default value of this parameter if it requires one
doc_stringDocumentation. This will be shown for –help
deprecation_messageThe message that will will print about why this param was deprecated. It might mention the "new way".

Definition at line 1780 of file InputParameters.h.

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

1784 {
1785  _show_deprecated_message = false;
1786  addParam<T>(name, value, doc_string);
1787 
1788  _params[name]._deprecation_message = deprecation_message;
1789  _show_deprecated_message = true;
1790 }
std::string name(const ElemQuality q)
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::map< std::string, Metadata > _params
The actual parameter data.

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

1797 {
1798  _show_deprecated_message = false;
1799  addParam<T>(name, doc_string);
1800 
1801  _params[name]._deprecation_message = deprecation_message;
1802  _show_deprecated_message = true;
1803 }
std::string name(const ElemQuality q)
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
std::map< std::string, Metadata > _params
The actual parameter data.

◆ addDeprecatedParam() [3/6]

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

Definition at line 1179 of file InputParameters.C.

1182 {
1183  mooseError("You must supply a MooseEnum object and the deprecation string when using "
1184  "addDeprecatedParam, even if the parameter is not required!");
1185 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284

◆ addDeprecatedParam() [4/6]

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

Definition at line 1189 of file InputParameters.C.

1192 {
1193  mooseError("You must supply a MultiMooseEnum object and the deprecation string when using "
1194  "addDeprecatedParam, even if the parameter is not required!");
1195 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284

◆ addDeprecatedParam() [5/6]

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

◆ addDeprecatedParam() [6/6]

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

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

Referenced by addDeprecatedCoupledVar(), ConstantReporter::addReporterTypeParams(), MultiAppTransfer::addSkipCoordCollapsingParam(), AdvancedOutput::addValidParams(), Moose::commonAdaptivityParams(), Moose::PetscSupport::getPetscValidParams(), Moose::SlepcSupport::getSlepcEigenProblemValidParams(), FVDiffusionInterface::validParams(), FVOneVarDiffusionInterface::validParams(), ArrayVariableComponent::validParams(), ValueRangeMarker::validParams(), ValueThresholdMarker::validParams(), ConstantVectorPostprocessor::validParams(), FileMesh::validParams(), TiledMesh::validParams(), ArrayVarReductionAux::validParams(), InversePowerMethod::validParams(), NonlinearEigen::validParams(), ADRobinBC::validParams(), ADVectorRobinBC::validParams(), CopyNodalVarsAction::validParams(), ArrayNeumannBC::validParams(), PenaltyDirichletNodalKernel::validParams(), ArrayHFEMDirichletBC::validParams(), ArrayPenaltyDirichletBC::validParams(), ArrayVacuumBC::validParams(), CreateExecutionerAction::validParams(), ElementIntegerAux::validParams(), HFEMDirichletBC::validParams(), FVFunctorTimeKernel::validParams(), FVMatAdvection::validParams(), FVReaction::validParams(), NumElems::validParams(), NumRelationshipManagers::validParams(), NumVars::validParams(), PerfGraphData::validParams(), Residual::validParams(), VectorPostprocessorReductionValue::validParams(), ElementStatistics::validParams(), EqualValueBoundaryConstraint::validParams(), ArrayTimeDerivative::validParams(), NodalStatistics::validParams(), MassEigenKernel::validParams(), DynamicObjectRegistrationAction::validParams(), ReadExecutorParamsAction::validParams(), TimeDerivative::validParams(), VectorTimeDerivative::validParams(), ErrorFractionMarker::validParams(), ErrorToleranceMarker::validParams(), DerivativeSumMaterialTempl< is_ad >::validParams(), CreateProblemAction::validParams(), JSONOutput::validParams(), AddFieldSplitAction::validParams(), ExtremeValueBase< SideVariablePostprocessor >::validParams(), ExtraIDIntegralReporter::validParams(), CoefReactionTempl< is_ad >::validParams(), ActivateElementsByPath::validParams(), ActivateElementsCoupled::validParams(), ThresholdElementSubdomainModifier::validParams(), CSVReaderVectorPostprocessor::validParams(), Eigenvalues::validParams(), FEProblemSolve::validParams(), SetupMeshAction::validParams(), UniqueExtraIDMeshGenerator::validParams(), GapValueAux::validParams(), MooseObjectAction::validParams(), TimeExtremeValue::validParams(), AdaptivityAction::validParams(), ActivateElementsUserObjectBase::validParams(), ElementQualityChecker::validParams(), PenetrationAux::validParams(), ElementSubdomainModifier::validParams(), ProjectionAux::validParams(), ConditionalEnableControl::validParams(), SetupDebugAction::validParams(), SecondTimeDerivativeAux::validParams(), SidesetInfoVectorPostprocessor::validParams(), TimeDerivativeAux::validParams(), ArrayDGDiffusion::validParams(), AnnularMesh::validParams(), GeneratedMesh::validParams(), SpiralAnnularMesh::validParams(), RinglebMesh::validParams(), AddMetaDataGenerator::validParams(), BlockDeletionGenerator::validParams(), BreakBoundaryOnSubdomainGenerator::validParams(), BreakMeshByBlockGeneratorBase::validParams(), CoarsenBlockGenerator::validParams(), ElementGenerator::validParams(), ExtraNodesetGenerator::validParams(), FileMeshGenerator::validParams(), FillBetweenCurvesGenerator::validParams(), FillBetweenPointVectorsGenerator::validParams(), FillBetweenSidesetsGenerator::validParams(), AdvectiveFluxAux::validParams(), LowerDBlockFromSidesetGenerator::validParams(), ConstantFunction::validParams(), MoveNodeGenerator::validParams(), PiecewiseConstant::validParams(), PlaneIDMeshGenerator::validParams(), RefineBlockGenerator::validParams(), RefineSidesetGenerator::validParams(), RenameBlockGenerator::validParams(), RenameBoundaryGenerator::validParams(), RinglebMeshGenerator::validParams(), SmoothMeshGenerator::validParams(), SphereMeshGenerator::validParams(), SpiralAnnularMeshGenerator::validParams(), SubdomainPerElementGenerator::validParams(), TiledMeshGenerator::validParams(), ConstantAux::validParams(), CoupledForceNodalKernel::validParams(), LowerBoundNodalKernel::validParams(), ReactionNodalKernel::validParams(), FVFunctorDirichletBCTempl< is_ad >::validParams(), UpperBoundNodalKernel::validParams(), DeprecatedBlockAction::validParams(), DirichletBCBase::validParams(), FVCoupledForce::validParams(), FunctorDirichletBC::validParams(), FunctorNeumannBC::validParams(), ConstantPostprocessor::validParams(), ElementExtremeFunctorValueTempl< is_ad >::validParams(), InterfaceDiffusion::validParams(), ScalarVariable::validParams(), ScalePostprocessor::validParams(), TimeIntegratedPostprocessor::validParams(), SingleMatrixPreconditioner::validParams(), RestartableDataReporter::validParams(), NullScalarKernel::validParams(), BoundsBase::validParams(), CoefTimeDerivative::validParams(), TimeIntervalTimes::validParams(), DivField::validParams(), GradField::validParams(), MultiAppCloneReporterTransfer::validParams(), FunctionDiffusion::validParams(), MultiAppReporterTransfer::validParams(), NullKernel::validParams(), ElemSideNeighborLayersTester::validParams(), GeometrySphere::validParams(), BoundaryMarker::validParams(), PIDTransientControl::validParams(), ExtraIDIntegralVectorPostprocessor::validParams(), SpatialAverageBase::validParams(), SpatialUserObjectVectorPostprocessor::validParams(), MaterialFunctorConverterTempl< T >::validParams(), ParsedMaterialBase::validParams(), ADDGAdvection::validParams(), ConcentricCircleMesh::validParams(), MaxIncrement::validParams(), ImageMesh::validParams(), MeshGeneratorMesh::validParams(), SetupResidualDebugAction::validParams(), CSVFileTimes::validParams(), FunctorBinnedValuesDivision::validParams(), ArrayParsedAux::validParams(), AnnularMeshGenerator::validParams(), VariableGradientComponent::validParams(), BreakMeshByBlockGenerator::validParams(), VectorPostprocessorVisualizationAux::validParams(), CartesianMeshGenerator::validParams(), VectorVariableComponentAux::validParams(), ConcentricCircleMeshGenerator::validParams(), CutMeshByPlaneGenerator::validParams(), GeneratedMeshGenerator::validParams(), MeshDiagnosticsGenerator::validParams(), MeshRepairGenerator::validParams(), ParsedSubdomainMeshGenerator::validParams(), PatchMeshGenerator::validParams(), PolyLineMeshGenerator::validParams(), PiecewiseLinear::validParams(), SideSetExtruderGenerator::validParams(), DivergenceAuxTempl< is_ad >::validParams(), SplineFunction::validParams(), FunctorADConverterTempl< T >::validParams(), FunctorSmootherTempl< T >::validParams(), TransformGenerator::validParams(), FVBoundaryScalarLagrangeMultiplierConstraint::validParams(), Console::validParams(), ControlOutput::validParams(), Receiver::validParams(), GMVOutput::validParams(), FunctorAux::validParams(), PerfGraphOutput::validParams(), FVAnisotropicDiffusion::validParams(), Tecplot::validParams(), VTKOutput::validParams(), DiffusionCG::validParams(), DiffusionFV::validParams(), FVMassMatrix::validParams(), MultiAppPositions::validParams(), TransformedPositions::validParams(), ChangeOverFixedPointPostprocessor::validParams(), ChangeOverTimePostprocessor::validParams(), GhostingAux::validParams(), MatchedValueBCTempl< is_ad >::validParams(), FVScalarLagrangeMultiplierConstraint::validParams(), InterfaceValueUserObjectAux::validParams(), NumNonlinearIterations::validParams(), ParsedPostprocessor::validParams(), PseudoTimestep::validParams(), MaterialRealDenseMatrixAux::validParams(), MaterialRealTensorValueAux::validParams(), PenaltyInterfaceDiffusionTempl< T, is_ad >::validParams(), FiniteDifferencePreconditioner::validParams(), MaterialStdVectorAuxTempl< is_ad >::validParams(), ADConservativeAdvection::validParams(), MaterialStdVectorRealGradientAux::validParams(), IterationInfo::validParams(), ParsedODEKernel::validParams(), ActuallyExplicitEuler::validParams(), NewmarkBeta::validParams(), Times::validParams(), FunctionDT::validParams(), ConservativeAdvection::validParams(), PostprocessorDT::validParams(), TimeSequenceStepperBase::validParams(), MultiAppConservativeTransfer::validParams(), EqualValueConstraint::validParams(), GeometryBase::validParams(), ReactionTempl< is_ad >::validParams(), ParsedAux::validParams(), NodalConstraint::validParams(), InterfaceValueUserObject::validParams(), ParsedVectorAux::validParams(), QuadraturePointMarker::validParams(), InterfaceQpMaterialPropertyBaseUserObject< Real >::validParams(), TiedValueConstraint::validParams(), WorkBalance::validParams(), ScalarTagMatrixAux::validParams(), MaterialVectorPostprocessor::validParams(), BoundingValueElementDamper::validParams(), PositionsFunctorValueSampler::validParams(), VariableValueVolumeHistogram::validParams(), ScalarTagVectorAux::validParams(), BoundingValueNodalDamper::validParams(), TagMatrixAux::validParams(), CartesianGridDivision::validParams(), CircularBoundaryCorrectionGenerator::validParams(), CylindricalGridDivision::validParams(), ADMatReaction::validParams(), SphericalGridDivision::validParams(), AdvancedExtruderGenerator::validParams(), VariableTimeIntegrationAux::validParams(), FunctorElementalGradientAuxTempl< is_ad >::validParams(), BreakMeshByElementGenerator::validParams(), ScalarKernelBase::validParams(), LeastSquaresFit::validParams(), CombinerGenerator::validParams(), BicubicSplineFunction::validParams(), ADMatCoupledForce::validParams(), CompositeFunction::validParams(), ImageMeshGenerator::validParams(), MeshExtruderGenerator::validParams(), ParsedCurveGenerator::validParams(), ADFunctionDirichletBC::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), ADVectorFunctionDirichletBC::validParams(), StackGenerator::validParams(), StitchBoundaryMeshGenerator::validParams(), ADVectorFunctionNeumannBC::validParams(), CreateDisplacedProblemAction::validParams(), FullSolveMultiApp::validParams(), ParsedFunctorMaterialTempl< is_ad >::validParams(), VectorMagnitudeFunctorMaterialTempl< is_ad >::validParams(), FVNeumannBC::validParams(), Constraint::validParams(), MaterialStdVectorAuxBaseTempl< Real, is_ad >::validParams(), FunctionGradientNeumannBC::validParams(), FunctorVectorElementalAuxTempl< is_ad >::validParams(), ElementGroupCentroidPositions::validParams(), Positions::validParams(), NormalizationAux::validParams(), StitchedMeshGenerator::validParams(), FunctionSideIntegral::validParams(), NeumannBCTempl< is_ad >::validParams(), MemoryUsage::validParams(), VectorCurlPenaltyDirichletBC::validParams(), VectorDivPenaltyDirichletBC::validParams(), VectorFunctionDirichletBC::validParams(), ReferenceResidualProblem::validParams(), MaterialDerivativeTestAction::validParams(), VectorPenaltyDirichletBC::validParams(), VectorFunctionReaction::validParams(), MeshDivisionAux::validParams(), FunctorTimes::validParams(), CoupledTiedValueConstraint::validParams(), CoupledForceTempl< is_ad >::validParams(), MultiAppShapeEvaluationTransfer::validParams(), EqualValueEmbeddedConstraint::validParams(), SetAdaptivityOptionsAction::validParams(), SolutionTimeAdaptiveDT::validParams(), VectorMemoryUsage::validParams(), XYMeshLineCutter::validParams(), FVOrthogonalDiffusion::validParams(), PiecewiseLinearInterpolationMaterial::validParams(), LeastSquaresFitHistory::validParams(), SetupQuadratureAction::validParams(), MaterialAuxBaseTempl< RealVectorValue, is_ad >::validParams(), CreateApplicationBlockAction::validParams(), CoarsenedPiecewiseLinear::validParams(), OrientedSubdomainBoundingBoxGenerator::validParams(), ParsedNodeTransformGenerator::validParams(), PiecewiseLinearFromVectorPostprocessor::validParams(), PiecewiseTabularBase::validParams(), FVFunctorNeumannBC::validParams(), CSV::validParams(), PointVariableSamplerBase::validParams(), GenericFunctorMaterialTempl< is_ad >::validParams(), GenericVectorFunctorMaterialTempl< is_ad >::validParams(), CoupledValueFunctionMaterialTempl< is_ad >::validParams(), DOFMapOutput::validParams(), FileOutput::validParams(), Gnuplot::validParams(), SolutionHistory::validParams(), SingleRankPartitioner::validParams(), XYDelaunayGenerator::validParams(), GenericFunctorGradientMaterialTempl< is_ad >::validParams(), DisplayGhostingAction::validParams(), GreaterThanLessThanPostprocessor::validParams(), MultiAppPostprocessorTransfer::validParams(), MultiAppPostprocessorInterpolationTransfer::validParams(), MatCoupledForce::validParams(), MultiAppVariableValueSamplePostprocessorTransfer::validParams(), MaterialPropertyValueTempl< is_ad >::validParams(), PointwiseRenormalizeVector::validParams(), MaterialADConverterTempl< T >::validParams(), PointSamplerBase::validParams(), ReporterPointSource::validParams(), FixedPointSolve::validParams(), ElementDeletionGeneratorBase::validParams(), ADConservativeAdvectionBC::validParams(), ParsedGenerateSideset::validParams(), LinearNodalConstraint::validParams(), ADPiecewiseLinearInterpolationMaterial::validParams(), FVFunctionNeumannBC::validParams(), ElementUOAux::validParams(), FVBodyForce::validParams(), RandomPartitioner::validParams(), IntegratedBCBase::validParams(), ElementIntegralFunctorPostprocessorTempl< is_ad >::validParams(), NumDOFs::validParams(), MaterialDerivativeTestKernelBase< Real >::validParams(), NodalScalarKernel::validParams(), EigenProblem::validParams(), VectorNeumannBC::validParams(), ADKernelSUPGTempl< T >::validParams(), FunctionValuePostprocessor::validParams(), ElementVectorL2Error::validParams(), ElemElemConstraint::validParams(), TagAuxBase< AuxKernel >::validParams(), VectorBodyForce::validParams(), MultiAppDofCopyTransfer::validParams(), MortarNodalAuxKernelTempl< ComputeValueType >::validParams(), SolutionAux::validParams(), SolutionScalarAux::validParams(), FindValueOnLine::validParams(), DerivativeKernelInterface< T >::validParams(), TimePeriod::validParams(), PetscExternalPartitioner::validParams(), TransfiniteMeshGenerator::validParams(), DiffusionPhysicsBase::validParams(), InterfaceQpUserObjectBase::validParams(), PostprocessorNeumannBC::validParams(), TimeStepper::validParams(), MultiAppGeneralFieldNearestLocationTransfer::validParams(), BoundingBoxIC::validParams(), MatReaction::validParams(), ElementIntegralArrayVariablePostprocessor::validParams(), LibtorchControlValuePostprocessor::validParams(), CSVTimeSequenceStepper::validParams(), MultiAppProjectionTransfer::validParams(), StitchedMesh::validParams(), ADMortarScalarBase::validParams(), ElementVariablesDifferenceMax::validParams(), ADKernelScalarBase::validParams(), KernelScalarBase::validParams(), TransientMultiApp::validParams(), FVOrthogonalBoundaryDiffusion::validParams(), CoupledVarNeumannBCTempl< false >::validParams(), SideIntegralFunctorPostprocessorTempl< is_ad >::validParams(), FieldSplitPreconditioner::validParams(), ElementSideNeighborLayers::validParams(), MortarScalarBase::validParams(), EigenKernel::validParams(), ADMatDiffusionBase< Real >::validParams(), MultiAppNearestNodeTransfer::validParams(), ADDGDiffusion::validParams(), PhysicsBase::validParams(), DGDiffusion::validParams(), FVDiffusion::validParams(), PNGOutput::validParams(), VariableResidualNormsDebugOutput::validParams(), MeshInfo::validParams(), ADDirichletBCBase::validParams(), MooseParsedVectorFunction::validParams(), PiecewiseMulticonstant::validParams(), Exodus::validParams(), VacuumBC::validParams(), LibmeshPartitioner::validParams(), InterfaceIntegralVariableValuePostprocessor::validParams(), LinearCombinationPostprocessor::validParams(), PiecewiseMultilinear::validParams(), AddPeriodicBCAction::validParams(), NodalVariableValue::validParams(), ExplicitTimeIntegrator::validParams(), Split::validParams(), ParsedElementDeletionGenerator::validParams(), PatternedMeshGenerator::validParams(), SubdomainBoundingBoxGenerator::validParams(), LibtorchNeuralNetControl::validParams(), MaterialRealVectorValueAuxTempl< is_ad >::validParams(), SideSetsGeneratorBase::validParams(), AdamsPredictor::validParams(), BodyForceTempl< is_ad >::validParams(), NodalPatchRecovery::validParams(), GhostingUserObject::validParams(), EigenExecutionerBase::validParams(), DistributedRectilinearMeshGenerator::validParams(), RelationshipManager::validParams(), NodalNormalsPreprocessor::validParams(), ADDirichletBCBaseTempl< Real >::validParams(), FVFunctionIC::validParams(), PiecewiseMultiInterpolation::validParams(), MatDiffusionBase< Real >::validParams(), SideAdvectiveFluxIntegralTempl< is_ad >::validParams(), SinNeumannBC::validParams(), SetupInterface::validParams(), FunctionIC::validParams(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::validParams(), Damper::validParams(), BoundingBoxNodeSetGenerator::validParams(), Axisymmetric2D3DSolutionFunction::validParams(), NodalBCBase::validParams(), CommonOutputAction::validParams(), PropertyReadFile::validParams(), AddNodalNormalsAction::validParams(), MooseParsedGradFunction::validParams(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::validParams(), VectorConstantIC::validParams(), MultiAppUserObjectTransfer::validParams(), DGFunctionDiffusionDirichletBC::validParams(), ComparisonPostprocessor::validParams(), MultiAppGeometricInterpolationTransfer::validParams(), TableOutput::validParams(), GenericFunctionVectorMaterialTempl< is_ad >::validParams(), InterfaceKernelBase::validParams(), Predictor::validParams(), GenericFunctionMaterialTempl< is_ad >::validParams(), ProjectedStatefulMaterialStorageAction::validParams(), VectorFunctionIC::validParams(), GridPartitioner::validParams(), AB2PredictorCorrector::validParams(), DiracKernelBase::validParams(), PatternedMesh::validParams(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::validParams(), ADNodalBCTempl< RealVectorValue, ADDirichletBCBase >::validParams(), ElementIndicator::validParams(), ADPenaltyPeriodicSegmentalConstraint::validParams(), PenaltyPeriodicSegmentalConstraint::validParams(), SolutionUserObject::validParams(), MultiAppTransfer::validParams(), FVKernel::validParams(), NodalUserObject::validParams(), TransientInterface::validParams(), BoundaryCondition::validParams(), Transient::validParams(), NodalKernelBase::validParams(), IterationAdaptiveDT::validParams(), FileRangeBuilder::validParams(), FunctionMaterialBase< is_ad >::validParams(), VectorPostprocessor::validParams(), Steady::validParams(), VariableCondensationPreconditioner::validParams(), NodeFaceConstraint::validParams(), ADPenaltyDirichletBC::validParams(), Material::validParams(), Indicator::validParams(), PenaltyDirichletBC::validParams(), FVFluxKernel::validParams(), RandomInterface::validParams(), InternalSideIndicator::validParams(), MoosePreconditioner::validParams(), Eigenvalue::validParams(), LayeredBase::validParams(), TaggingInterface::validParams(), MortarConsumerInterface::validParams(), MooseObject::validParams(), RandomIC::validParams(), OversampleOutput::validParams(), DerivativeParsedMaterialHelperTempl< is_ad >::validParams(), MultiAppGeneralFieldTransfer::validParams(), MooseVariableBase::validParams(), RandomICBase::validParams(), Terminator::validParams(), AuxScalarKernel::validParams(), PetscOutput::validParams(), BoundaryRestrictable::validParams(), ShapeUserObject< SideUserObject >::validParams(), MooseParsedFunctionBase::validParams(), OutputInterface::validParams(), DGKernelBase::validParams(), Transfer::validParams(), NestedSolveTempl< is_ad >::validParams(), Control::validParams(), MeshGenerator::validParams(), Action::validParams(), ScalarInitialCondition::validParams(), MortarConstraintBase::validParams(), PiecewiseBilinear::validParams(), Executioner::validParams(), DomainUserObject::validParams(), AStableDirk4::validParams(), Output::validParams(), MeshBaseImageSampler::validParams(), UserObject::validParams(), FunctionParserUtils< false >::validParams(), Sampler::validParams(), ImageSampler::validParams(), ParsedMaterialHelper< is_ad >::validParams(), InitialConditionBase::validParams(), Checkpoint::validParams(), FVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), Moose::Builder::validParams(), BlockRestrictable::validParams(), MaterialPropertyInterface::validParams(), AuxKernelTempl< Real >::validParams(), TopResidualDebugOutput::validParams(), SubProblem::validParams(), MaterialBase::validParams(), MooseMesh::validParams(), MooseApp::validParams(), MultiApp::validParams(), Executor::validParams(), and FEProblemBase::validParams().

1519 {
1520  checkParamName(name);
1521  checkConsistentType<T>(name);
1522 
1523  T & l_value = InputParameters::set<T>(name);
1524  auto & metadata = _params[name];
1525  if (std::is_same_v<T, MooseFunctorName>)
1526  metadata._doc_string = appendFunctorDescription(doc_string);
1527  else
1528  metadata._doc_string = doc_string;
1529 
1530  // Set the parameter now
1531  setParamHelper(name, l_value, value);
1532 
1533  /* Indicate the default value, as set via addParam, is being used. The parameter is removed from
1534  the list whenever
1535  it changes, see set_attributes */
1536  metadata._set_by_add_param = true;
1537 }
std::string name(const ElemQuality q)
void checkParamName(const std::string &name) const
Make sure the parameter name doesn&#39;t have any invalid characters.
std::string appendFunctorDescription(const std::string &doc_string) const
Appends description of what a functor is to a doc string.
std::map< std::string, Metadata > _params
The actual parameter data.
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-matchi...

◆ addParam() [2/7]

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

Definition at line 1541 of file InputParameters.h.

1542 {
1543  checkParamName(name);
1544  checkConsistentType<T>(name);
1545 
1546  InputParameters::insert<T>(name);
1547  if (std::is_same_v<T, MooseFunctorName>)
1548  _params[name]._doc_string = appendFunctorDescription(doc_string);
1549  else
1550  _params[name]._doc_string = doc_string;
1551 }
std::string name(const ElemQuality q)
void checkParamName(const std::string &name) const
Make sure the parameter name doesn&#39;t have any invalid characters.
std::string appendFunctorDescription(const std::string &doc_string) const
Appends description of what a functor is to a doc string.
std::map< std::string, Metadata > _params
The actual parameter data.

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

233  {
234  addParam<T>(name, T{value}, doc_string);
235  }
std::string name(const ElemQuality q)
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ addParam() [4/7]

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

Definition at line 1136 of file InputParameters.C.

1138 {
1139  mooseError("You must supply a MooseEnum object when using addParam, even if the parameter is not "
1140  "required!");
1141 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284

◆ addParam() [5/7]

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

Definition at line 1145 of file InputParameters.C.

1147 {
1148  mooseError("You must supply a MultiMooseEnum object when using addParam, even if the parameter "
1149  "is not required!");
1150 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284

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

Referenced by MultiAppTransfer::addSkipCoordCollapsingParam(), AdvancedOutput::addValidParams(), Moose::PetscSupport::getPetscValidParams(), Moose::SlepcSupport::getSlepcEigenProblemValidParams(), CopyNodalVarsAction::validParams(), NodalPatchRecoveryBase::validParams(), DerivativeSumMaterialTempl< is_ad >::validParams(), MooseObjectAction::validParams(), SetupMeshAction::validParams(), GeneratedMesh::validParams(), Times::validParams(), MultiAppConservativeTransfer::validParams(), MaterialStdVectorAuxTempl< is_ad >::validParams(), Console::validParams(), GMVOutput::validParams(), Tecplot::validParams(), VTKOutput::validParams(), DiffusionFV::validParams(), ScalarKernelBase::validParams(), AdvancedExtruderGenerator::validParams(), SetAdaptivityOptionsAction::validParams(), Constraint::validParams(), Positions::validParams(), LeastSquaresFitHistory::validParams(), PiecewiseTabularBase::validParams(), CSV::validParams(), FileOutput::validParams(), FixedPointSolve::validParams(), IntegratedBCBase::validParams(), TransfiniteMeshGenerator::validParams(), DiffusionPhysicsBase::validParams(), TransientMultiApp::validParams(), Exodus::validParams(), PhysicsBase::validParams(), SideSetsGeneratorBase::validParams(), NodalPatchRecovery::validParams(), Postprocessor::validParams(), EigenExecutionerBase::validParams(), NodalBCBase::validParams(), InterfaceKernelBase::validParams(), TableOutput::validParams(), DiracKernelBase::validParams(), NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::validParams(), SolutionUserObject::validParams(), FVKernel::validParams(), TransientInterface::validParams(), NodalKernelBase::validParams(), Transient::validParams(), BoundaryCondition::validParams(), RadialAverage::validParams(), VectorPostprocessor::validParams(), Material::validParams(), Indicator::validParams(), RandomInterface::validParams(), ProjectedStatefulMaterialNodalPatchRecoveryTempl< T, is_ad >::validParams(), FVFluxKernel::validParams(), LayeredBase::validParams(), Eigenvalue::validParams(), TaggingInterface::validParams(), OversampleOutput::validParams(), MooseObject::validParams(), MultiAppGeneralFieldTransfer::validParams(), MooseVariableBase::validParams(), AuxScalarKernel::validParams(), PetscOutput::validParams(), ShapeUserObject< SideUserObject >::validParams(), DGKernelBase::validParams(), OutputInterface::validParams(), MeshGenerator::validParams(), Executioner::validParams(), Output::validParams(), MeshBaseImageSampler::validParams(), UserObject::validParams(), FunctionParserUtils< false >::validParams(), ImageSampler::validParams(), InitialConditionBase::validParams(), FVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), AuxKernelTempl< Real >::validParams(), SubProblem::validParams(), MultiApp::validParams(), and FEProblemBase::validParams().

869 {
870  std::vector<std::string> elements;
871  MooseUtils::tokenize(space_delim_names, elements, 1, " \t\n\v\f\r"); // tokenize on whitespace
872 
873  // Since we don't require types (templates) for this method, we need
874  // to get a raw list of parameter names to compare against.
875  std::set<std::string> param_names;
876  for (const auto & it : *this)
877  param_names.insert(it.first);
878 
879  for (const auto & param_name : elements)
880  if (_params.count(param_name) > 0)
881  _params[param_name]._group = group_name;
882  else
883  mooseError("Unable to find a parameter with name: ",
884  param_name,
885  " when adding to group ",
886  group_name,
887  '.');
888 }
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
Definition: MooseUtils.h:779
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::map< std::string, Metadata > _params
The actual parameter data.

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

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

1667 {
1668  checkParamName(name);
1669  checkConsistentType<T>(name);
1670 
1671  InputParameters::set<T>(name) = value;
1672  auto & metadata = _params[name];
1673  metadata._is_private = true;
1674  metadata._set_by_add_param = true;
1675 }
std::string name(const ElemQuality q)
void checkParamName(const std::string &name) const
Make sure the parameter name doesn&#39;t have any invalid characters.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ addPrivateParam() [2/6]

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

Definition at line 1655 of file InputParameters.h.

1656 {
1657  checkParamName(name);
1658  checkConsistentType<T>(name);
1659 
1660  InputParameters::insert<T>(name);
1661  _params[name]._is_private = true;
1662 }
std::string name(const ElemQuality q)
void checkParamName(const std::string &name) const
Make sure the parameter name doesn&#39;t have any invalid characters.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ addPrivateParam() [3/6]

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

Definition at line 1163 of file InputParameters.C.

1164 {
1165  mooseError("You must supply a MooseEnum object when using addPrivateParam, even if the parameter "
1166  "is not required!");
1167 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284

◆ addPrivateParam() [4/6]

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

Definition at line 1171 of file InputParameters.C.

1172 {
1173  mooseError("You must supply a MultiMooseEnum object when using addPrivateParam, even if the "
1174  "parameter is not required!");
1175 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284

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

Referenced by MultiAppTransfer::addBBoxFactorParam(), Moose::commonAdaptivityParams(), ConstantDT::validParams(), ErrorFractionMarker::validParams(), PeriodicFunction::validParams(), LogConstantDT::validParams(), AnnularMesh::validParams(), CoarsenBlockGenerator::validParams(), FillBetweenCurvesGenerator::validParams(), GeneratedMesh::validParams(), FillBetweenPointVectorsGenerator::validParams(), FillBetweenSidesetsGenerator::validParams(), AnnularMeshGenerator::validParams(), ConcentricCircleMesh::validParams(), NewmarkBeta::validParams(), ConcentricCircleMeshGenerator::validParams(), ImageMesh::validParams(), EqualValueConstraint::validParams(), GeneratedMeshGenerator::validParams(), CircularBoundaryCorrectionGenerator::validParams(), ParsedCurveGenerator::validParams(), ElementLpNormAux::validParams(), ImageMeshGenerator::validParams(), CylindricalGridDivision::validParams(), SphericalGridDivision::validParams(), AdvancedExtruderGenerator::validParams(), XYDelaunayGenerator::validParams(), FixedPointSolve::validParams(), TimeStepper::validParams(), TransfiniteMeshGenerator::validParams(), ElementSideNeighborLayers::validParams(), PNGOutput::validParams(), PatternedMeshGenerator::validParams(), ElementPointNeighborLayers::validParams(), SideSetsGeneratorBase::validParams(), DistributedRectilinearMeshGenerator::validParams(), PatternedMesh::validParams(), ElementW1pError::validParams(), IterationAdaptiveDT::validParams(), RadialAverage::validParams(), MultiAppGeneralFieldTransfer::validParams(), MooseVariableBase::validParams(), DerivativeFunctionMaterialBaseTempl< is_ad >::validParams(), Output::validParams(), and MultiApp::validParams().

1591 {
1592  addParam<T>(name, value, doc_string);
1593  _params[name]._range_function = parsed_function;
1594 }
std::string name(const ElemQuality q)
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::map< std::string, Metadata > _params
The actual parameter data.

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

1601 {
1602  addParam<T>(name, doc_string);
1603  _params[name]._range_function = parsed_function;
1604 }
std::string name(const ElemQuality q)
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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
nameThe name of the RelationshipManager type
rm_typeThe 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_callbackThis 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 503 of file InputParameters.C.

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

507 {
508  _buildable_rm_types.emplace_back(name, rm_type, input_parameter_callback);
509 }
std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > _buildable_rm_types
The RelationshipManagers that this object may either build or require.

◆ 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
nameThe name of the parameter
syntaxSpace separated list of command-line switch syntax that can set this option
doc_stringDocumentation. This will be shown for –help

Definition at line 1679 of file InputParameters.h.

1682 {
1683  addRequiredParam<T>(name, doc_string);
1684  addCommandLineParamHelper<T>(name, syntax);
1685 }
std::string name(const ElemQuality q)

◆ addRequiredCoupledVar()

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

This method adds a coupled variable name pair.

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

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

Definition at line 321 of file InputParameters.C.

Referenced by transferParam(), ArrayVariableComponent::validParams(), FVScalarLagrangeMultiplierInterface::validParams(), VariableInnerProduct::validParams(), ElementVariableStatistics::validParams(), NodalVariableStatistics::validParams(), CoupledODETimeDerivative::validParams(), CoupledVarThresholdElementSubdomainModifier::validParams(), LowerDIntegratedBC::validParams(), ArrayVarReductionAux::validParams(), SideVariablePostprocessor::validParams(), ActivateElementsCoupled::validParams(), SideValueSampler::validParams(), DerivativeSumMaterialTempl< is_ad >::validParams(), ElementVariablePostprocessor::validParams(), VectorVariableMagnitudeAux::validParams(), ArrayCoupledTimeDerivative::validParams(), InterfaceQpValueUserObject::validParams(), ElementVariableVectorPostprocessor::validParams(), ArrayLowerDIntegratedBC::validParams(), NodalVariableVectorPostprocessor::validParams(), CoupledTimeDerivative::validParams(), DivField::validParams(), ADVectorMatchedValueBC::validParams(), GradField::validParams(), VectorCoupledTimeDerivative::validParams(), ProjectionAux::validParams(), CoupledForceNodalKernel::validParams(), LowerBoundNodalKernel::validParams(), UpperBoundNodalKernel::validParams(), SecondTimeDerivativeAux::validParams(), CopyValueAux::validParams(), ElementL2Difference::validParams(), VectorMagnitudeAux::validParams(), VectorVariableComponentAux::validParams(), FVBoundaryScalarLagrangeMultiplierConstraint::validParams(), DiffusionFluxAux::validParams(), FVScalarLagrangeMultiplierConstraint::validParams(), ConservativeAdvection::validParams(), VariableGradientComponent::validParams(), MatchedValueBCTempl< is_ad >::validParams(), VectorFromComponentVariablesMaterialTempl< is_ad >::validParams(), VariableTimeIntegrationAux::validParams(), ElementLpNormAux::validParams(), CoupledForceTempl< is_ad >::validParams(), NormalizationAux::validParams(), ScalarTagMatrixAux::validParams(), ElementHCurlSemiError::validParams(), ElementHDivSemiError::validParams(), NodalVariablePostprocessor::validParams(), MatCoupledForce::validParams(), NearestNodeValueAux::validParams(), OneDEqualValueConstraintBC::validParams(), PiecewiseLinearInterpolationMaterial::validParams(), PointVariableSamplerBase::validParams(), MaterialDerivativeTestKernelBase< Real >::validParams(), InterpolatedStatefulMaterialTempl< T >::validParams(), ADPiecewiseLinearInterpolationMaterial::validParams(), TagAuxBase< AuxKernel >::validParams(), SideIntegralVariableUserObject::validParams(), ElementIntegralVariableUserObject::validParams(), NodalEqualValueConstraint::validParams(), ElementIntegralVariablePostprocessor::validParams(), ElementIntegralArrayVariablePostprocessor::validParams(), ElementVariablesDifferenceMax::validParams(), CoupledVarNeumannBCTempl< false >::validParams(), DGLowerDKernel::validParams(), SideIntegralVariablePostprocessor::validParams(), InterfaceIntegralVariableValuePostprocessor::validParams(), InternalSideIntegralVariablePostprocessor::validParams(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::validParams(), ArrayDGLowerDKernel::validParams(), HFEMTestJump::validParams(), CompositeTensorBase< T, U >::validParams(), HFEMTrialJump::validParams(), InterfaceKernelBase::validParams(), PeriodicSegmentalConstraint::validParams(), ADPenaltyPeriodicSegmentalConstraint::validParams(), PenaltyPeriodicSegmentalConstraint::validParams(), NodeElemConstraint::validParams(), ADPeriodicSegmentalConstraint::validParams(), and ScalarLagrangeMultiplier::validParams().

322 {
323  addRequiredParam<std::vector<VariableName>>(name, doc_string);
324  _coupled_vars.insert(name);
325 }
std::string name(const ElemQuality q)
std::set< std::string > _coupled_vars
The coupled variables set.

◆ addRequiredCoupledVarWithAutoBuild()

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

Definition at line 310 of file InputParameters.C.

314 {
315  addRequiredParam<std::vector<VariableName>>(name, doc_string);
316 
317  addCoupledVarWithAutoBuild(name, base_name, num_name, doc_string);
318 }
std::string name(const ElemQuality q)
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.

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

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

1611 {
1612  addRequiredParam<T>(name, doc_string);
1613  _params[name]._custom_type = custom_type;
1614 }
std::string name(const ElemQuality q)
std::map< std::string, Metadata > _params
The actual parameter data.

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

Referenced by FVDiffusionInterface::validParams(), FVOneVarDiffusionInterface::validParams(), EqualValueBoundaryConstraint::validParams(), AnalyticalIndicator::validParams(), PenaltyDirichletNodalKernel::validParams(), ArrayDiffusion::validParams(), ArrayReaction::validParams(), PerfGraphData::validParams(), DGConvection::validParams(), IndicatorMarker::validParams(), VariableResidual::validParams(), VectorPostprocessorComponent::validParams(), VectorPostprocessorReductionValue::validParams(), UniformMarker::validParams(), ValueRangeMarker::validParams(), ConstantDT::validParams(), GenericConstant2DArray::validParams(), GenericConstantArray::validParams(), TestSourceStepper::validParams(), FileMesh::validParams(), TiledMesh::validParams(), BoundaryDeletionGenerator::validParams(), ConstantVectorPostprocessor::validParams(), ExtraElementIDAux::validParams(), ArrayPenaltyDirichletBC::validParams(), FVAdvection::validParams(), FVMatAdvection::validParams(), ExtraIDIntegralReporter::validParams(), ActivateElementsCoupled::validParams(), GenericConstantVectorMaterialTempl< is_ad >::validParams(), NodalPatchRecoveryBase::validParams(), PeriodicFunction::validParams(), ThresholdElementSubdomainModifier::validParams(), LineValueSampler::validParams(), PointValueSampler::validParams(), MooseObjectAction::validParams(), UniqueExtraIDMeshGenerator::validParams(), FunctionScalarIC::validParams(), ArrayFunctionIC::validParams(), ElementExtremeMaterialPropertyTempl< is_ad >::validParams(), PenetrationAux::validParams(), ElementL2Error::validParams(), NodalPatchRecoveryAuxBase::validParams(), ArrayBodyForce::validParams(), TimeExtremeValue::validParams(), BoxMarker::validParams(), ActivateElementsUserObjectBase::validParams(), ElementQualityChecker::validParams(), GapValueAux::validParams(), CSVReaderVectorPostprocessor::validParams(), OverlayMeshGenerator::validParams(), FVPostprocessorDirichletBC::validParams(), SymmetryTransformGenerator::validParams(), TiledMeshGenerator::validParams(), SubdomainPerElementGenerator::validParams(), BoundsBase::validParams(), ScalarComponentIC::validParams(), ElementExtremeFunctorValueTempl< is_ad >::validParams(), FunctionElementIntegral::validParams(), NodalL2Error::validParams(), ProjectedMaterialPropertyNodalPatchRecoveryAux::validParams(), ScalePostprocessor::validParams(), ScalarVariable::validParams(), ComboMarker::validParams(), AdvectiveFluxAux::validParams(), BoundaryMarker::validParams(), ExplicitSSPRungeKutta::validParams(), ArrayDGDiffusion::validParams(), MultiAppCloneReporterTransfer::validParams(), FunctionDiracSource::validParams(), MultiAppReporterTransfer::validParams(), AnnularMesh::validParams(), FunctionArrayAux::validParams(), ElemSideNeighborLayersGeomTester::validParams(), GeneratedMesh::validParams(), ElemSideNeighborLayersTester::validParams(), JSONFileReader::validParams(), RinglebMesh::validParams(), NestedDivision::validParams(), ElementsAlongLine::validParams(), ElementsAlongPlane::validParams(), IntersectionPointsAlongLine::validParams(), LineFunctionSampler::validParams(), BlockToMeshConverterGenerator::validParams(), ExtraElementIntegerDivision::validParams(), BreakBoundaryOnSubdomainGenerator::validParams(), CoarsenBlockGenerator::validParams(), FVFunctorDirichletBCTempl< is_ad >::validParams(), ElementGenerator::validParams(), ElementsToTetrahedronsConverter::validParams(), ExtraNodesetGenerator::validParams(), FileMeshGenerator::validParams(), FillBetweenCurvesGenerator::validParams(), FillBetweenPointVectorsGenerator::validParams(), FillBetweenSidesetsGenerator::validParams(), FlipSidesetGenerator::validParams(), LowerDBlockFromSidesetGenerator::validParams(), MoveNodeGenerator::validParams(), DebugResidualAux::validParams(), NodeSetsFromSideSetsGenerator::validParams(), ConstantScalarAux::validParams(), PlaneIDMeshGenerator::validParams(), RefineBlockGenerator::validParams(), FunctorDirichletBC::validParams(), FunctorNeumannBC::validParams(), RefineSidesetGenerator::validParams(), RenameBlockGenerator::validParams(), RenameBoundaryGenerator::validParams(), RinglebMeshGenerator::validParams(), FVCoupledForce::validParams(), SideSetsFromNodeSetsGenerator::validParams(), SideSetsFromNormalsGenerator::validParams(), SmoothMeshGenerator::validParams(), SubdomainIDGenerator::validParams(), TransformGenerator::validParams(), MultiAppScalarToAuxScalarTransfer::validParams(), DivergenceAuxTempl< is_ad >::validParams(), IntegralPreservingFunctionIC::validParams(), FilePositions::validParams(), InputPositions::validParams(), MultiAppPositions::validParams(), ReporterPositions::validParams(), TransformedPositions::validParams(), ChangeOverFixedPointPostprocessor::validParams(), ChangeOverTimePostprocessor::validParams(), ConstantBounds::validParams(), InterfaceReaction::validParams(), ElementLengthAux::validParams(), EqualGradientConstraint::validParams(), PenaltyInterfaceDiffusionTempl< T, is_ad >::validParams(), ElementL2FunctorErrorTempl< is_ad >::validParams(), ADConservativeAdvection::validParams(), NearestNodeNumber::validParams(), ParsedPostprocessor::validParams(), MaterialDerivativeRankFourTestKernel::validParams(), PseudoTimestep::validParams(), VectorFromComponentVariablesMaterialTempl< is_ad >::validParams(), DiffusionFluxAux::validParams(), MaterialDerivativeRankTwoTestKernel::validParams(), PIDTransientControl::validParams(), AnnularMeshGenerator::validParams(), BoundaryPreservedMarker::validParams(), AccumulateReporter::validParams(), CSVFileTimes::validParams(), ReporterPointMarker::validParams(), ExodusFileTimes::validParams(), InputTimes::validParams(), ReporterTimes::validParams(), Times::validParams(), QuadraturePointMarker::validParams(), ExodusTimeSequenceStepper::validParams(), PostprocessorDT::validParams(), TimeSequenceStepper::validParams(), ADDGAdvection::validParams(), MultiAppConservativeTransfer::validParams(), MultiAppPostprocessorToAuxScalarTransfer::validParams(), ConstantPointSource::validParams(), TagVectorArrayVariableValueAux::validParams(), Distribution::validParams(), ConcentricCircleMesh::validParams(), VectorPostprocessorVisualizationAux::validParams(), MessageFromInput::validParams(), NearestNodeNumberUO::validParams(), LinearCombinationFunction::validParams(), CylindricalAverage::validParams(), ExtraIDIntegralVectorPostprocessor::validParams(), FunctorBinnedValuesDivision::validParams(), PiecewiseConstantFromCSV::validParams(), SpatialAverageBase::validParams(), SpatialUserObjectVectorPostprocessor::validParams(), BreakMeshByBlockGenerator::validParams(), CartesianMeshGenerator::validParams(), SplineFunction::validParams(), CutMeshByPlaneGenerator::validParams(), ConcentricCircleMeshGenerator::validParams(), FunctorAux::validParams(), ImageSubdomainGenerator::validParams(), GeneratedMeshGenerator::validParams(), MeshDiagnosticsGenerator::validParams(), MeshRepairGenerator::validParams(), ParsedSubdomainMeshGenerator::validParams(), FVAnisotropicDiffusion::validParams(), SideSetExtruderGenerator::validParams(), GhostingAux::validParams(), SideSetsFromPointsGenerator::validParams(), InterfaceValueUserObjectAux::validParams(), PostprocessorDirichletBC::validParams(), ArrayConstantIC::validParams(), AdvancedExtruderGenerator::validParams(), VectorCurlPenaltyDirichletBC::validParams(), VectorDirichletBC::validParams(), DistributedPositions::validParams(), VectorDivPenaltyDirichletBC::validParams(), FunctorPositions::validParams(), MeshDivisionAux::validParams(), VectorPenaltyDirichletBC::validParams(), Positions::validParams(), NearestNodeDistanceAux::validParams(), DifferencePostprocessor::validParams(), CombinerGenerator::validParams(), InterfaceQpMaterialPropertyBaseUserObject< Real >::validParams(), ElementHCurlSemiError::validParams(), ElementHDivSemiError::validParams(), ElementL1Error::validParams(), EqualValueEmbeddedConstraint::validParams(), VectorConstantPointSource::validParams(), NumMeshDivisions::validParams(), NumPositions::validParams(), BoolFunctionControl::validParams(), FunctionScalarAux::validParams(), SolutionTimeAdaptiveDT::validParams(), ConditionalFunctionEnableControl::validParams(), TimeSequenceFromTimes::validParams(), MaterialVectorPostprocessor::validParams(), FunctorTimes::validParams(), ADFunctionNeumannBC::validParams(), ADDirichletBC::validParams(), SpatialUserObjectAux::validParams(), GenericConstantRankTwoTensorTempl< is_ad >::validParams(), StitchedMeshGenerator::validParams(), TagVectorAux::validParams(), MultiAppVariableValueSampleTransfer::validParams(), TagVectorArrayVariableAux::validParams(), ElementQualityAux::validParams(), BicubicSplineFunction::validParams(), CylindricalGridDivision::validParams(), LeastSquaresFit::validParams(), GenericFunctionRankTwoTensorTempl< is_ad >::validParams(), NodalNormalsCorner::validParams(), VectorFunctionAux::validParams(), LayeredSideDiffusiveFluxAverage::validParams(), FunctionAux::validParams(), PositionsFunctorValueSampler::validParams(), VariableValueVolumeHistogram::validParams(), BreakMeshByElementGenerator::validParams(), CircularBoundaryCorrectionGenerator::validParams(), ParsedFunctorMaterialTempl< is_ad >::validParams(), FunctionNeumannBC::validParams(), MaterialDerivativeTestAction::validParams(), VectorMagnitudeFunctorMaterialTempl< is_ad >::validParams(), FVConstantScalarOutflowBC::validParams(), ArrayDirichletBC::validParams(), FVDirichletBC::validParams(), FVFunctionDirichletBC::validParams(), DirichletBC::validParams(), FunctorElementalGradientAuxTempl< is_ad >::validParams(), MeshCollectionGenerator::validParams(), FunctionGradientNeumannBC::validParams(), MeshExtruderGenerator::validParams(), ParsedCurveGenerator::validParams(), PercentChangePostprocessor::validParams(), FunctorVectorElementalAuxTempl< is_ad >::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), StackGenerator::validParams(), StitchBoundaryMeshGenerator::validParams(), PiecewiseLinearFromVectorPostprocessor::validParams(), MultiAppVectorPostprocessorTransfer::validParams(), FunctionElementIntegralUserObject::validParams(), XYDelaunayGenerator::validParams(), ConstantRate::validParams(), MaterialPropertyValueTempl< is_ad >::validParams(), CumulativeValuePostprocessor::validParams(), ElementIntegralMaterialPropertyTempl< is_ad >::validParams(), BlockWeightedPartitioner::validParams(), NearestNodeValueAux::validParams(), GreaterThanLessThanPostprocessor::validParams(), CoarsenedPiecewiseLinear::validParams(), MeshDivisionFunctorReductionVectorPostprocessor::validParams(), ConstantDamper::validParams(), VectorOfPostprocessors::validParams(), XYMeshLineCutter::validParams(), CoupledValueFunctionMaterialTempl< is_ad >::validParams(), OneDEqualValueConstraintBC::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), PiecewiseLinearInterpolationMaterial::validParams(), MultiAppVariableValueSamplePostprocessorTransfer::validParams(), MultiAppPostprocessorInterpolationTransfer::validParams(), LeastSquaresFitHistory::validParams(), FVFunctorNeumannBC::validParams(), FunctionDirichletBC::validParams(), MultiAppPostprocessorTransfer::validParams(), OrientedSubdomainBoundingBoxGenerator::validParams(), MaterialAuxBaseTempl< RealVectorValue, is_ad >::validParams(), PointValue::validParams(), ParsedNodeTransformGenerator::validParams(), NearestPositionsDivision::validParams(), AnisotropicDiffusion::validParams(), MatNeumannBCTempl< is_ad >::validParams(), FVOrthogonalDiffusion::validParams(), MaterialRankFourTensorAux::validParams(), ReporterPointSource::validParams(), ElementIntegralFunctorPostprocessorTempl< is_ad >::validParams(), MaterialDerivativeTestKernelBase< Real >::validParams(), ElementH1SemiError::validParams(), FunctionValuePostprocessor::validParams(), ADPiecewiseLinearInterpolationMaterial::validParams(), InterpolatedStatefulMaterialTempl< T >::validParams(), ElementUOAux::validParams(), ElementDeletionGeneratorBase::validParams(), FVFunctionNeumannBC::validParams(), ParsedGenerateSideset::validParams(), SideIntegralFunctorUserObject::validParams(), LinearNodalConstraint::validParams(), TransfiniteMeshGenerator::validParams(), UserForcingFunctionNodalKernel::validParams(), ElementL2ErrorFunctionAux::validParams(), ElementalVariableValue::validParams(), ScalarConstantIC::validParams(), LibtorchControlValuePostprocessor::validParams(), SolutionAux::validParams(), BoundingBoxIC::validParams(), SolutionScalarAux::validParams(), AuxNodalScalarKernel::validParams(), PlaneDeletionGenerator::validParams(), FVDivergence::validParams(), MultiAppCopyTransfer::validParams(), TagVectorSum::validParams(), CSVTimeSequenceStepper::validParams(), SideIntegralFunctorPostprocessorTempl< is_ad >::validParams(), OrientedBoxMarker::validParams(), GenericConstantMaterialTempl< is_ad >::validParams(), StitchedMesh::validParams(), LibtorchArtificialNeuralNetParameters::validParams(), ContainsPointAux::validParams(), FieldSplitPreconditioner::validParams(), ScalarL2Error::validParams(), BoundaryRestrictableRequired::validParams(), FVOrthogonalBoundaryDiffusion::validParams(), PNGOutput::validParams(), LinearCombinationPostprocessor::validParams(), LibmeshPartitioner::validParams(), DGDiffusion::validParams(), FVConstantIC::validParams(), HistogramVectorPostprocessor::validParams(), FVDiffusion::validParams(), ADDGDiffusion::validParams(), RealFunctionControl::validParams(), LibtorchNeuralNetControl::validParams(), PatternedMeshGenerator::validParams(), NodalVariableValue::validParams(), SideSetsGeneratorBase::validParams(), ParsedElementDeletionGenerator::validParams(), SubdomainBoundingBoxGenerator::validParams(), NodalNormalsPreprocessor::validParams(), FVFunctionIC::validParams(), FunctionIC::validParams(), ADFunctionPenaltyDirichletBC::validParams(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::validParams(), DistributedRectilinearMeshGenerator::validParams(), RelationshipManager::validParams(), SideAdvectiveFluxIntegralTempl< is_ad >::validParams(), EigenExecutionerBase::validParams(), ProxyRelationshipManager::validParams(), VectorConstantIC::validParams(), Axisymmetric2D3DSolutionFunction::validParams(), FVBoundedValueConstraint::validParams(), CompositeTensorBase< T, U >::validParams(), NodalDamper::validParams(), DumpObjectsProblem::validParams(), MaterialRankTwoTensorAuxTempl< is_ad >::validParams(), BoundingBoxNodeSetGenerator::validParams(), FunctionPenaltyDirichletBC::validParams(), PropertyReadFile::validParams(), CompileTimeDerivativesMaterial< N, is_ad, MaxD >::validParams(), ComparisonPostprocessor::validParams(), DGFunctionDiffusionDirichletBC::validParams(), Predictor::validParams(), ElementDamper::validParams(), MultiAppUserObjectTransfer::validParams(), PatternedMesh::validParams(), FVPointValueConstraint::validParams(), AB2PredictorCorrector::validParams(), NodeElemConstraint::validParams(), SolutionUserObject::validParams(), ConstantIC::validParams(), ElementIndicator::validParams(), PostprocessorComparison::validParams(), ElementW1pError::validParams(), PhysicsBasedPreconditioner::validParams(), RelativeDifferencePostprocessor::validParams(), VectorPostprocessorComparison::validParams(), AverageValueConstraint::validParams(), ScalarSolutionIC::validParams(), PostprocessorSpatialUserObject::validParams(), IterationAdaptiveDT::validParams(), ScalarLMKernelTempl< is_ad >::validParams(), RadialAverage::validParams(), VariableCondensationPreconditioner::validParams(), PenaltyDirichletBC::validParams(), ADPenaltyDirichletBC::validParams(), InternalSideIndicator::validParams(), ProjectedStatefulMaterialNodalPatchRecoveryTempl< T, is_ad >::validParams(), SamplerBase::validParams(), LayeredBase::validParams(), SolutionIC::validParams(), MortarConsumerInterface::validParams(), AuxScalarKernel::validParams(), LineMaterialSamplerBase< Real >::validParams(), OrientedBoxInterface::validParams(), FVInitialConditionBase::validParams(), InitialConditionBase::validParams(), FVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), AuxKernelTempl< Real >::validParams(), and MultiApp::validParams().

1493 {
1494  checkParamName(name);
1495  checkConsistentType<T>(name);
1496 
1497  InputParameters::insert<T>(name);
1498  auto & metadata = _params[name];
1499  metadata._required = true;
1500  if (std::is_same_v<T, MooseFunctorName>)
1501  metadata._doc_string = appendFunctorDescription(doc_string);
1502  else
1503  metadata._doc_string = doc_string;
1504 }
std::string name(const ElemQuality q)
void checkParamName(const std::string &name) const
Make sure the parameter name doesn&#39;t have any invalid characters.
std::string appendFunctorDescription(const std::string &doc_string) const
Appends description of what a functor is to a doc string.
std::map< std::string, Metadata > _params
The actual parameter data.

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

1511 {
1512  mooseError("You cannot call addRequiredParam and supply a default value for this type, please "
1513  "use addParam instead");
1514 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284

◆ addRequiredParam() [3/6]

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

Definition at line 1097 of file InputParameters.C.

1100 {
1101  InputParameters::set<MooseEnum>(name) = moose_enum; // valid parameter is set by set_attributes
1102  auto & metadata = _params[name];
1103  metadata._required = true;
1104  metadata._doc_string = doc_string;
1105 }
std::string name(const ElemQuality q)
std::map< std::string, Metadata > _params
The actual parameter data.

◆ addRequiredParam() [4/6]

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

Definition at line 1109 of file InputParameters.C.

1112 {
1113  InputParameters::set<MultiMooseEnum>(name) =
1114  moose_enum; // valid parameter is set by set_attributes
1115  auto & metadata = _params[name];
1116  metadata._required = true;
1117  metadata._doc_string = doc_string;
1118 }
std::string name(const ElemQuality q)
std::map< std::string, Metadata > _params
The actual parameter data.

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

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

Referenced by ActionWarehouse::printInputFile().

1187 { _allow_copy = status; }
bool _allow_copy
A flag for toggling the error message in the copy constructor.
MPI_Status status

◆ appendFunctorDescription()

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

Referenced by addParam(), and addRequiredParam().

1210 {
1211  return MooseUtils::trim(doc_string, ". ") +
1212  ". A functor is any of the following: a variable, a functor material property, a "
1213  "function, a post-processor, or a number.";
1214 }
std::string trim(const std::string &str, const std::string &white_space=" \\\)
Standard scripting language trim function.
Definition: MooseUtils.C:214

◆ 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
commonThe set of InputParameters from which to extract the coupled variable's properties
var_nameThe 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 991 of file InputParameters.C.

Referenced by applyParameters(), and applySpecificParameters().

992 {
993  // Disable the display of deprecated message when applying common parameters, this avoids a dump
994  // of messages
995  _show_deprecated_message = false;
996 
997  // If the local parameters has a coupled variable, populate it with the value from the common
998  // parameters, if the common parameters has the coupled variable too
999  if (hasCoupledValue(var_name))
1000  {
1001  if (common.hasDefaultCoupledValue(var_name))
1002  {
1003  // prepare a vector of default coupled values
1004  std::vector<Real> defaults(common.numberDefaultCoupledValues(var_name));
1005  for (unsigned int j = 0; j < common.numberDefaultCoupledValues(var_name); ++j)
1006  defaults[j] = common.defaultCoupledValue(var_name, j);
1007  addCoupledVar(var_name, defaults, common.getDocString(var_name));
1008  }
1009  else if (common.hasCoupledValue(var_name))
1010  addCoupledVar(var_name, common.getDocString(var_name));
1011  }
1012 
1013  // Enable deprecated message printing
1014  _show_deprecated_message = true;
1015 }
bool hasCoupledValue(const std::string &coupling_name) const
Return whether or not the coupled variable exists.
unsigned int numberDefaultCoupledValues(const std::string &coupling_name) const
Get the number of defaulted coupled value entries.
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
std::string getDocString(const std::string &name) const
Returns the documentation string for the specified parameter name.
bool hasDefaultCoupledValue(const std::string &coupling_name) const
Return whether or not the requested parameter has a default coupled value.
Real defaultCoupledValue(const std::string &coupling_name, unsigned int i=0) const
Get the default value for an optionally coupled variable.
void addCoupledVar(const std::string &name, const std::string &doc_string)
This method adds a coupled variable name pair.

◆ 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
commonThe set of InputParameters from which to extract parameters from
common_nameThe 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 1018 of file InputParameters.C.

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

1021 {
1022  // Disable the display of deprecated message when applying common parameters, this avoids a dump
1023  // of messages
1024  _show_deprecated_message = false;
1025 
1026  const auto local_name = checkForRename(common_name);
1027 
1028  // Extract the properties from the local parameter for the current common parameter name
1029  const bool local_exist = _values.find(local_name) != _values.end();
1030  const bool local_set = _params.count(local_name) > 0 && !_params[local_name]._set_by_add_param;
1031  const bool local_priv = allow_private ? false : isPrivate(local_name);
1032  const bool local_valid = isParamValid(local_name);
1033 
1034  // Extract the properties from the common parameter
1035  const bool common_exist = common._values.find(common_name) != common._values.end();
1036  const bool common_priv = allow_private ? false : common.isPrivate(common_name);
1037  const bool common_valid = common.isParamValid(common_name);
1038 
1039  /* In order to apply a common parameter 4 statements must be satisfied
1040  * (1) A local parameter must exist with the same name as the common parameter
1041  * (2) Common parameter must be valid and exist
1042  * (3) Local parameter must be invalid OR not have been set from its default
1043  * (4) Both cannot be private
1044  */
1045  if (local_exist && common_exist && common_valid && (!local_valid || !local_set) &&
1046  (!common_priv || !local_priv))
1047  {
1048  remove(local_name);
1049  _values[local_name] = common._values.find(common_name)->second->clone();
1050  set_attributes(local_name, false);
1051  _params[local_name]._set_by_add_param =
1052  libmesh_map_find(common._params, common_name)._set_by_add_param;
1053  // Keep track of where this param came from if we can. This will enable us to
1054  // produce param errors from objects created within an action that link to
1055  // the parameter in the action
1056  at(local_name)._hit_node = common.getHitNode(common_name);
1057  }
1058 
1059  // Enable deprecated message printing
1060  _show_deprecated_message = true;
1061 }
const hit::Node * getHitNode(const std::string &param) const
const hit::Node * _hit_node
Original location of parameter node; used for error messages.
bool isPrivate(const std::string &name) const
Returns a Boolean indicating whether the specified parameter is private or not.
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.
virtual void set_attributes(const std::string &name, bool inserted_only) override
Override from libMesh to set user-defined attributes on our parameter.
Metadata & at(const std::string &param_name)
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ applyParameters()

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

Method for applying common parameters.

Parameters
commonThe set of parameters to apply to the parameters stored in this object
excludeA 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 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 919 of file InputParameters.C.

Referenced by FEProblemBase::addOutput(), OversampleOutput::cloneMesh(), MooseServer::parseDocumentForDiagnostics(), and ProjectedStatefulMaterialStorageAction::processProperty().

922 {
923  // If we're applying all of the things, also associate the top level hit node
924  if (exclude.empty() && !getHitNode() && common.getHitNode())
925  setHitNode(*common.getHitNode(), {});
926 
927  // Loop through the common parameters
928  for (const auto & it : common)
929  {
930  // Common parameter name
931  const std::string & common_name = it.first;
932  // Continue to next parameter, if the current is in list of excluded parameters
933  if (std::find(exclude.begin(), exclude.end(), common_name) != exclude.end())
934  continue;
935 
936  applyParameter(common, common_name, allow_private);
937  }
938 
939  // Loop through the coupled variables
940  for (std::set<std::string>::const_iterator it = common.coupledVarsBegin();
941  it != common.coupledVarsEnd();
942  ++it)
943  {
944  // Variable name
945  const std::string var_name = *it;
946 
947  // Continue to next variable, if the current is in list of excluded parameters
948  if (std::find(exclude.begin(), exclude.end(), var_name) != exclude.end())
949  continue;
950 
951  applyCoupledVar(common, var_name);
952  }
953 }
const hit::Node * getHitNode(const std::string &param) const
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 ...
void applyParameter(const InputParameters &common, const std::string &common_name, bool allow_private=false)
Apply values from a single parameter in common, to a single parameter stored in this object...
void setHitNode(const std::string &param, const hit::Node &node, const SetParamHitNodeKey)
Sets the hit node associated with the parameter param to node.
const hit::Node * getHitNode() const

◆ applySpecificParameters()

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

Method for applying common parameters.

Parameters
commonThe set of parameters to apply to the parameters stored in this object
includeA 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 956 of file InputParameters.C.

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

959 {
960  // Loop through the common parameters
961  for (const auto & it : common)
962  {
963 
964  // Common parameter name
965  const std::string & common_name = it.first;
966 
967  // Continue to next parameter, if the current is not in list of included parameters
968  if (std::find(include.begin(), include.end(), common_name) == include.end())
969  continue;
970 
971  applyParameter(common, common_name, allow_private);
972  }
973 
974  // Loop through the coupled variables
975  for (std::set<std::string>::const_iterator it = common.coupledVarsBegin();
976  it != common.coupledVarsEnd();
977  ++it)
978  {
979  // Variable name
980  const std::string var_name = *it;
981 
982  // Continue to next variable, if the current is not in list of included parameters
983  if (std::find(include.begin(), include.end(), var_name) == include.end())
984  continue;
985 
986  applyCoupledVar(common, var_name);
987  }
988 }
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 ...
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...

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

Referenced by ActionWarehouse::buildBuildableActions().

414 {
415  for (const auto & it : *this)
416  if (isParamRequired(it.first) && !isParamValid(it.first))
417  return false;
418  return true;
419 }
bool isParamRequired(const std::string &name) const
Returns a boolean indicating whether the specified parameter is required or not.
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ at() [1/2]

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

Definition at line 1163 of file InputParameters.h.

Referenced by addCommandLineParamHelper(), applyParameter(), getCommandLineMetadata(), getControllableExecuteOnTypes(), getHitNode(), isCommandLineParameter(), and setHitNode().

1164  {
1165  const auto param = checkForRename(param_name);
1166  if (_params.count(param) == 0)
1167  mooseError("param '", param, "' not present in InputParams");
1168  return _params[param];
1169  }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ at() [2/2]

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

Definition at line 1170 of file InputParameters.h.

1171  {
1172  const auto param = checkForRename(param_name);
1173  if (_params.count(param) == 0)
1174  mooseError("param '", param, "' not present in InputParams");
1175  return _params.at(param);
1176  }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ attemptPrintDeprecated()

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

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

Definition at line 110 of file InputParameters.C.

111 {
112  const auto name = checkForRename(name_in);
114  {
115  auto emit_deprecation_message =
116  [this](const auto & deprecated_name, const auto & deprecation_message)
117  {
118  // This is user-facing, no need for a backtrace
119  const auto current_show_trace = Moose::show_trace;
120  Moose::show_trace = false;
122  Moose::out, false, true, errorPrefix(deprecated_name), ":\n", deprecation_message, "\n");
123  Moose::show_trace = current_show_trace;
124  return true;
125  };
126 
127  if (_params.count(name) && !libmesh_map_find(_params, name)._deprecation_message.empty())
128  return emit_deprecation_message(name,
129  "The parameter '" + name + "' is deprecated.\n" +
130  libmesh_map_find(_params, name)._deprecation_message);
131  else if (auto it = _old_to_new_name_and_dep.find(name_in);
132  it != _old_to_new_name_and_dep.end() && !it->second.second.empty())
133  return emit_deprecation_message(name_in, it->second.second);
134  }
135  return false;
136 }
std::string name(const ElemQuality q)
bool show_trace
Set to true (the default) to print the stack trace with error and warning messages - false to omit it...
Definition: Moose.C:642
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, Args &&... args)
Definition: MooseError.h:236
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.
std::string errorPrefix(const std::string &param) const
generate error message prefix with parameter name and location (if available)
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 dep...

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

Referenced by AddFVICAction::act(), AddICAction::act(), AddAuxKernelAction::act(), checkParams(), MooseBaseParameterInterface::getRenamedParam(), MooseApp::getRenamedParam(), and MooseObjectAction::MooseObjectAction().

1362 {
1363  if (const auto hit_node = getHitNode())
1364  return hit_node->fullpath();
1365  return "";
1366 }
const hit::Node * getHitNode() const

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

Referenced by checkParams().

1354 {
1355  if (const auto hit_node = getHitNode())
1356  return hit_node->fileLocation(/* with_column = */ false);
1357  return "";
1358 }
const hit::Node * getHitNode() const

◆ callMooseErrorHelper()

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

Definition at line 1610 of file InputParameters.C.

Referenced by getParamHelper().

1611 {
1612  moose_base.callMooseError(error, true);
1613 }
void callMooseError(std::string msg, const bool with_prefix) const
Calls moose error with the message msg.
Definition: MooseBase.C:33

◆ 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
namethe name of the parameter

Definition at line 1710 of file InputParameters.h.

1711 {
1712  const auto name = checkForRename(name_in);
1713 
1714  // If we don't currently have the Parameter, can't be any inconsistency
1715  InputParameters::const_iterator it = _values.find(name);
1716  if (it == _values.end())
1717  return;
1718 
1719  // Now, if we already have the Parameter, but it doesn't have the
1720  // right type, throw an error.
1721  if (!this->Parameters::have_parameter<T>(name))
1722  mooseError("Attempting to set parameter \"",
1723  name,
1724  "\" with type (",
1725  demangle(typeid(T).name()),
1726  ")\nbut the parameter already exists as type (",
1727  it->second->type(),
1728  ")");
1729 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string demangle(const char *name)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.

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

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

1589 {
1590  if (auto it = _old_to_new_name_and_dep.find(name); it != _old_to_new_name_and_dep.end())
1591  return it->second.first;
1592  else
1593  return name;
1594 }
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 dep...

◆ checkParamName()

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

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

Definition at line 1400 of file InputParameters.C.

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

1401 {
1402  const static pcrecpp::RE valid("[\\w:/]+");
1403  if (!valid.FullMatch(name))
1404  mooseError("Invalid parameter name: '", name, "'");
1405 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::vector< ElemQuality > valid(const ElemType t)

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

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

570 {
571  std::string parampath = blockFullpath() != "" ? blockFullpath() : parsing_syntax;
572  std::ostringstream oss;
573  // Required parameters
574  for (const auto & it : *this)
575  {
576  const auto param_name = checkForRename(it.first);
577  if (!isParamValid(param_name) && isParamRequired(param_name))
578  {
579  // check if an old, deprecated name exists for this parameter that may be specified
580  auto oit = _new_to_deprecated_coupled_vars.find(param_name);
581  if (oit != _new_to_deprecated_coupled_vars.end() && isParamValid(oit->second))
582  continue;
583 
584  oss << blockLocation() << ": missing required parameter '" << parampath + "/" + param_name
585  << "'\n";
586  oss << "\tDoc String: \"" + getDocString(param_name) + "\"" << std::endl;
587  }
588  }
589 
590  // Range checked parameters
591  for (const auto & it : *this)
592  {
593  std::string long_name(parampath + "/" + it.first);
594 
595  dynamicCastRangeCheck(Real, Real, long_name, it.first, it.second, oss);
596  dynamicCastRangeCheck(int, long, long_name, it.first, it.second, oss);
597  dynamicCastRangeCheck(long, long, long_name, it.first, it.second, oss);
598  dynamicCastRangeCheck(unsigned int, long, long_name, it.first, it.second, oss);
599  }
600 
601  // Controllable parameters
602  for (const auto & param_name : getControllableParameters())
603  {
604  if (isPrivate(param_name))
605  oss << inputLocation(param_name) << ": private parameter '" << paramFullpath(param_name)
606  << "' marked controllable";
607 
608  checkMooseType(NonlinearVariableName, param_name);
609  checkMooseType(AuxVariableName, param_name);
610  checkMooseType(VariableName, param_name);
611  checkMooseType(BoundaryName, param_name);
612  checkMooseType(SubdomainName, param_name);
613  checkMooseType(PostprocessorName, param_name);
614  checkMooseType(VectorPostprocessorName, param_name);
615  checkMooseType(UserObjectName, param_name);
616  checkMooseType(MaterialPropertyName, param_name);
617  }
618 
619  if (!oss.str().empty())
620  mooseError(oss.str());
621 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::unordered_map< std::string, std::string > _new_to_deprecated_coupled_vars
A map from deprecated coupled variable names to the new blessed name.
bool isPrivate(const std::string &name) const
Returns a Boolean indicating whether the specified parameter is private or not.
std::string getDocString(const std::string &name) const
Returns the documentation string for the specified parameter name.
std::string inputLocation(const std::string &param) const
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::string blockFullpath() const
bool isParamRequired(const std::string &name) const
Returns a boolean indicating whether the specified parameter is required or not.
std::string blockLocation() const
std::set< std::string > getControllableParameters() const
Return list of controllable parameters.
std::string paramFullpath(const std::string &param) const
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ clear()

void InputParameters::clear ( )
overridevirtual

Definition at line 63 of file InputParameters.C.

64 {
65  Parameters::clear();
66  _params.clear();
67  _coupled_vars.clear();
69  _collapse_nesting = false;
72  _allow_copy = true;
73  _block_fullpath = "";
74  _block_location = "";
76  _new_to_old_names.clear();
77  _hit_node = nullptr;
78  _finalized = false;
79 }
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...
bool _allow_copy
A flag for toggling the error message in the copy constructor.
std::string _block_location
original location of input block (i.e. filename,linenum) - used for nice error messages.
std::unordered_map< std::string, std::string > _new_to_deprecated_coupled_vars
A map from deprecated coupled variable names to the new blessed name.
std::string _block_fullpath
full HIT path of the block from the input file - used for nice error messages.
bool _show_deprecated_message
Flag for disabling deprecated parameters message, this is used by applyParameters to avoid dumping me...
bool _collapse_nesting
This parameter collapses one level of nesting in the syntax blocks.
std::set< std::string > _coupled_vars
The coupled variables set.
bool _finalized
Whether or not we&#39;ve called finalize() on these parameters yet.
const hit::Node * _hit_node
The hit node representing the syntax that created these parameters, if any.
bool _moose_object_syntax_visibility
This parameter hides derived MOOSE object types from appearing in syntax dumps.
std::map< std::string, Metadata > _params
The actual parameter data.
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 dep...

◆ clearRelationshipManagers()

void InputParameters::clearRelationshipManagers ( )
inline

Clears all currently registered RelationshipManagers.

Definition at line 630 of file InputParameters.h.

Referenced by ElemSideNeighborLayersGeomTester::validParams().

630 { _buildable_rm_types.clear(); }
std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > _buildable_rm_types
The RelationshipManagers that this object may either build or require.

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

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

527 {
528  _collapse_nesting = collapse;
529 }
bool _collapse_nesting
This parameter collapses one level of nesting in the syntax blocks.

◆ collapseSyntaxNesting() [2/2]

bool InputParameters::collapseSyntaxNesting ( ) const

Definition at line 532 of file InputParameters.C.

533 {
534  return _collapse_nesting;
535 }
bool _collapse_nesting
This parameter collapses one level of nesting in the syntax blocks.

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

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

708  {
709  return _coupled_vars.begin();
710  }
std::set< std::string > _coupled_vars
The coupled variables set.

◆ coupledVarsEnd()

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

Definition at line 711 of file InputParameters.h.

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

712  {
713  return _coupled_vars.end();
714  }
std::set< std::string > _coupled_vars
The coupled variables set.

◆ declareControllable()

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

Declare the given parameters as controllable.

Definition at line 429 of file InputParameters.C.

Referenced by GenericConstant2DArray::validParams(), PenaltyDirichletNodalKernel::validParams(), GenericConstantArray::validParams(), GenericConstantVectorMaterialTempl< is_ad >::validParams(), ConstantScalarAux::validParams(), ConstantFunction::validParams(), ConstantPostprocessor::validParams(), ConstantAux::validParams(), ReactionTempl< is_ad >::validParams(), ConstantPointSource::validParams(), DirichletBC::validParams(), NeumannBCTempl< is_ad >::validParams(), ADDirichletBC::validParams(), VectorDirichletBC::validParams(), ArrayDirichletBC::validParams(), VectorConstantPointSource::validParams(), PiecewiseTabularBase::validParams(), PiecewiseLinearInterpolationMaterial::validParams(), ConstantRate::validParams(), FunctionValuePostprocessor::validParams(), FVBodyForce::validParams(), VectorBodyForce::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(), Output::validParams(), UserObject::validParams(), FVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), AuxKernelTempl< Real >::validParams(), MultiApp::validParams(), and FEProblemBase::validParams().

431 {
432  std::vector<std::string> names;
433  MooseUtils::tokenize<std::string>(input_names, names, 1, " ");
434  for (auto & name_in : names)
435  {
436  const auto name = checkForRename(name_in);
437  auto map_iter = _params.find(name);
438  if (map_iter != _params.end()) // error is handled by checkParams method
439  {
440  map_iter->second._controllable = true;
441  map_iter->second._controllable_flags = execute_flags;
442  }
443  else
444  mooseError("The input parameter '",
445  name,
446  "' does not exist, thus cannot be marked as controllable.");
447  }
448 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.
ExecFlagEnum execute_flags
Storage for the registered execute flags.

◆ 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_nameThe name of the coupling parameter to get the default value for.
iBy default 0, in general the index of the requested coupled default value.

Definition at line 750 of file InputParameters.C.

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

751 {
752  auto value_it = _params.find(coupling_name);
753 
754  if (value_it == _params.end() || !value_it->second._have_coupled_default)
755  mooseError("Attempted to retrieve default value for coupled variable '",
756  coupling_name,
757  "' when none was provided. \n\nThere are three reasons why this may have "
758  "occurred:\n 1. The other version of params.addCoupledVar() should be used in order "
759  "to provide a default value. \n 2. This should have been a required coupled "
760  "variable added with params.addRequiredCoupledVar() \n 3. The call to get the "
761  "coupled value should have been properly guarded with isCoupled()\n");
762 
763  return value_it->second._coupled_default.at(i);
764 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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_nameThe name of the coupling parameter to get the default value for.
valueDefault value to set.
iBy default 0, in general the index of the requested coupled default value.

Definition at line 742 of file InputParameters.C.

743 {
744  _params[coupling_name]._coupled_default.resize(i + 1);
745  _params[coupling_name]._coupled_default[i] = value;
746  _params[coupling_name]._have_coupled_default = true;
747 }
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::map< std::string, Metadata > _params
The actual parameter data.

◆ deprecateCoupledVar()

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

Definition at line 1580 of file InputParameters.C.

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

1583 {
1584  renameCoupledVarInternal(old_name, new_name, "", removal_date);
1585 }
void renameCoupledVarInternal(const std::string &old_name, const std::string &new_name, const std::string &docstring, const std::string &removal_date)

◆ deprecateParam()

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

Definition at line 1572 of file InputParameters.C.

Referenced by SideSetsFromNormalsGenerator::validParams(), ParsedAux::validParams(), ParsedODEKernel::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), PicardSolve::validParams(), SideSetsGeneratorBase::validParams(), CommonOutputAction::validParams(), and Output::validParams().

1575 {
1576  renameParamInternal(old_name, new_name, "", removal_date);
1577 }
void renameParamInternal(const std::string &old_name, const std::string &new_name, const std::string &docstring, const std::string &removal_date)

◆ errorPrefix()

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

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

Definition at line 1456 of file InputParameters.C.

Referenced by attemptPrintDeprecated(), get(), getParamFileBase(), and paramErrorPrefix().

1457 {
1458  auto prefix = param + ":";
1459  if (!inputLocation(param).empty())
1460  prefix = inputLocation(param) + ": (" + paramFullpath(param) + ")";
1461  return prefix;
1462 }
std::string inputLocation(const std::string &param) const
std::string paramFullpath(const std::string &param) const

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

Referenced by AppFactory::createShared(), and Factory::initialize().

625 {
626  mooseAssert(!isFinalized(), "Already finalized");
627 
628  checkParams(parsing_syntax);
629 
630  // Helper for setting the absolute paths for each set file name parameter
631  const auto set_absolute_path = [this](const std::string & param_name, auto & value)
632  {
633  // We don't need to set a path if nothing is there
634  if (value.empty())
635  return;
636 
637  std::filesystem::path value_path = std::string(value);
638  // Is already absolute, nothing to do
639  if (value_path.is_absolute())
640  return;
641 
642  // The base by which to make things relative to
643  const auto file_base = getParamFileBase(param_name);
644  value = std::filesystem::absolute(file_base / value_path).c_str();
645  };
646 
647  // Set the absolute path for each file name typed parameter
648  for (const auto & [param_name, param_value] : *this)
649  {
650 #define set_if_filename(type) \
651  else if (auto type_value = dynamic_cast<Parameters::Parameter<type> *>(param_value.get())) \
652  set_absolute_path(param_name, type_value->set()); \
653  else if (auto type_values = dynamic_cast<Parameters::Parameter<std::vector<type>> *>( \
654  param_value.get())) for (auto & value : type_values->set()) \
655  set_absolute_path(param_name, value)
656 
657  if (false)
658  ;
659  // Note that we explicitly skip DataFileName here because we do not want absolute
660  // file paths for data files, as they're searched in the data directories
661  set_if_filename(FileName);
662  set_if_filename(FileNameNoExtension);
663  set_if_filename(MeshFileName);
664 #undef set_if_filename
665  }
666 
667  _finalized = true;
668 }
std::filesystem::path getParamFileBase(const std::string &param_name) const
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
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 th...
bool isFinalized() const
bool _finalized
Whether or not we&#39;ve called finalize() on these parameters yet.

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

Referenced by ElementIDOutputAction::act(), AddMaterialAction::act(), SplitMeshAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), SetupDebugAction::act(), MaterialOutputAction::act(), ActionWarehouse::addActionBlock(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxVariable(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), NonlinearSystemBase::addDGKernel(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVKernel(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), MooseEigenSystem::addKernel(), AuxiliarySystem::addKernel(), NonlinearSystemBase::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), NonlinearSystemBase::addNodalKernel(), FEProblemBase::addNodalKernel(), MooseObjectWarehouseBase< Indicator >::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), JsonSyntaxTree::addParameters(), Action::addRelationshipManager(), FEProblemBase::addScalarKernel(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), MooseServer::addValuesToList(), AuxiliarySystem::addVariable(), AddVariableAction::addVariable(), SystemBase::addVariable(), FEProblemBase::addVariable(), FVFluxKernel::adjustRMGhostLayers(), assemble_l2(), Moose::assemble_matrix(), AuxKernelTempl< Real >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), Moose::Builder::buildFullTree(), Moose::Builder::buildJsonSyntaxTree(), PostprocessorInterface::checkParam(), Moose::SlepcSupport::clearFreeNonlinearPowerIterations(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), MooseBaseParameterInterface::connectControllableParams(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), PostprocessorInterface::coupledPostprocessors(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), Coupleable::coupledVectorTagValues(), ActionFactory::create(), AddVariableAction::createInitialConditionAction(), AppFactory::createShared(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), Postprocessor::declareValue(), FunctorInterface::deduceFunctorName(), AddVariableAction::feType(), FileRangeBuilder::FileRangeBuilder(), FVAdvection::FVAdvection(), FVAnisotropicDiffusion::FVAnisotropicDiffusion(), FVDiffusion::FVDiffusion(), GapValueAux::GapValueAux(), ParsedSubdomainMeshGenerator::generate(), MooseServer::getActionParameters(), MooseApp::getCheckpointDirectories(), DistributionInterface::getDistribution(), ElementIDInterface::getElementID(), ElementIDInterface::getElementIDByName(), ElementIDInterface::getElementIDIndex(), ElementIDInterface::getElementIDNeighbor(), ElementIDInterface::getElementIDNeighborByName(), FunctionInterface::getFunction(), MaterialBase::getGenericZeroMaterialProperty(), MooseServer::getHoverDisplayText(), MaterialPropertyInterface::getMaterial(), MaterialPropertyInterface::getMaterialDataType(), MaterialPropertyInterface::getMaterialPropertyName(), MooseServer::getObjectParameters(), MooseBaseParameterInterface::getParam(), getParamHelper(), PostprocessorInterface::getPostprocessorNameInternal(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), SamplerInterface::getSampler(), AddVariableAction::getSubdomainIDs(), CommonOutputAction::hasConsole(), MeshGeneratorSystem::hasDataDrivenAllowed(), FunctionInterface::hasFunction(), MeshGenerator::hasGenerateData(), ImageSampler::ImageSampler(), AddVariableAction::init(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LayeredBase::LayeredBase(), SetupMeshAction::modifyParamsForUseSplit(), MooseApp::MooseApp(), MooseVariableInterface< Real >::MooseVariableInterface(), NodeFaceConstraint::NodeFaceConstraint(), operator=(), OrientedBoxInterface::OrientedBoxInterface(), OutputInterface::OutputInterface(), ConsoleUtils::outputLegacyInformation(), ParsedMaterialBase::ParsedMaterialBase(), PenetrationAux::PenetrationAux(), ProjectedStatefulMaterialStorageAction::ProjectedStatefulMaterialStorageAction(), ReferenceResidualProblem::ReferenceResidualProblem(), InputParameterWarehouse::removeInputParameters(), OutputWarehouse::resetFileBase(), Moose::SlepcSupport::setEigenProblemSolverParams(), Moose::SlepcSupport::setNewtonPetscOptions(), MooseMesh::setPartitioner(), FVKernel::setRMParams(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), CreateExecutionerAction::setupAutoPreconditioning(), ReadExecutorParamsAction::setupAutoPreconditioning(), MeshBaseImageSampler::setupImageSampler(), ImageSampler::setupImageSampler(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Reporter::store(), Moose::PetscSupport::storePetscOptions(), Moose::SlepcSupport::storeSolveType(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), transferParam(), MooseBaseParameterInterface::uniqueName(), MooseBaseParameterInterface::uniqueParameterName(), FVFunctorDirichletBCTempl< is_ad >::validParams(), ElemSideNeighborLayersGeomTester::validParams(), ElemSideNeighborLayersTester::validParams(), ProjectionAux::validParams(), FunctorElementalGradientAuxTempl< is_ad >::validParams(), NearestRadiusLayeredAverage::validParams(), DistributedRectilinearMeshGenerator::validParams(), FVKernel::validParams(), MortarConsumerInterface::validParams(), MortarConstraintBase::validParams(), FVInterfaceKernel::validParams(), Coupleable::vectorTagDofValueHelper(), Coupleable::vectorTagValueHelper(), MeshBaseImageSampler::vtkFlip(), MeshBaseImageSampler::vtkShiftAndScale(), ImageSampler::vtkShiftAndScale(), MeshBaseImageSampler::vtkThreshold(), ImageSampler::vtkThreshold(), and Moose::Builder::walkRaw().

1940 {
1941  const auto param1 = checkForRename(param1_in);
1942  const auto param2 = checkForRename(param2_in);
1943 
1944  const auto & v1 = get<V1>(param1);
1945  const auto & v2 = get<V2>(param2);
1946 
1947  auto controllable = getControllableParameters();
1948  if (controllable.count(param1) || controllable.count(param2))
1949  mooseError(errorPrefix(param1),
1950  " and/or ",
1951  errorPrefix(param2) +
1952  " are controllable parameters and cannot be retireved using "
1953  "the MooseObject::getParam/InputParameters::get methods for pairs");
1954 
1955  if (v1.size() != v2.size())
1956  mooseError("Vector parameters ",
1957  errorPrefix(param1),
1958  "(size: ",
1959  v1.size(),
1960  ") and " + errorPrefix(param2),
1961  "(size: ",
1962  v2.size(),
1963  ") are of different lengths \n");
1964 
1965  std::vector<std::pair<R1, R2>> parameter_pairs;
1966  auto i1 = v1.begin();
1967  auto i2 = v2.begin();
1968  for (; i1 != v1.end() && i2 != v2.end(); ++i1, ++i2)
1969  parameter_pairs.emplace_back(std::make_pair(*i1, *i2));
1970  return parameter_pairs;
1971 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::string errorPrefix(const std::string &param) const
generate error message prefix with parameter name and location (if available)
std::set< std::string > getControllableParameters() const
Return list of controllable parameters.

◆ 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
nameThe name to query the parameter values map with
Returns
The parameter value corresponding to the (possibly renamed) name

Definition at line 1988 of file InputParameters.h.

1989 {
1990  const auto name = checkForRename(std::string(name_in));
1991 
1992  return Parameters::get<T>(name);
1993 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter 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 778 of file InputParameters.C.

779 {
780  std::map<std::string, std::pair<std::string, std::string>> abv;
781  for (auto it = _params.begin(); it != _params.end(); ++it)
782  {
783  if (!it->second._autobuild_vecs.first.empty())
784  abv[it->first] = it->second._autobuild_vecs;
785  }
786  return abv;
787 }
std::map< std::string, Metadata > _params
The actual parameter data.

◆ getBase()

std::optional< std::string > InputParameters::getBase ( ) const
Returns
The base system of the object these parameters are for, if any

Definition at line 472 of file InputParameters.C.

Referenced by MooseBase::errorPrefix().

473 {
474  if (have_parameter<std::string>("_moose_base"))
475  return get<std::string>("_moose_base");
476  return {};
477 }

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

Referenced by Action::addRelationshipManagers().

521 {
522  return _buildable_rm_types;
523 }
std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > _buildable_rm_types
The RelationshipManagers that this object may either build or require.

◆ getBuildableTypes()

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

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

Definition at line 512 of file InputParameters.C.

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

513 {
514  return _buildable_types;
515 }
std::vector< std::string > _buildable_types
The parameter is used to restrict types that can be built.

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

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

1478 {
1479  const auto name = checkForRename(name_in);
1480 
1481  T param = this->get<T>(name);
1482 
1483  // Note: You will receive a compile error on this line if you attempt to pass a non-pointer
1484  // template type to this method
1485  if (param == NULL)
1486  mooseError("Parameter ", name, " is NULL.\n", error_string);
1487  return this->get<T>(name);
1488 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.

◆ getClassDescription()

std::string InputParameters::getClassDescription ( ) const

Returns the class description.

Definition at line 139 of file InputParameters.C.

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

140 {
141  return _class_description;
142 }
std::string _class_description
The class description for the owning object.

◆ getCommandLineArgumentType()

InputParameters::CommandLineMetadata::ArgumentType InputParameters::getCommandLineArgumentType ( const std::string &  name) const
Returns
The command line argument type for the parameter name

Definition at line 903 of file InputParameters.C.

904 {
906 }
ArgumentType argument_type
The type of argument.
const CommandLineMetadata & getCommandLineMetadata(const std::string &name) const

◆ getCommandLineMetadata()

const InputParameters::CommandLineMetadata & InputParameters::getCommandLineMetadata ( const std::string &  name) const
private
Returns
The command line metadata for the parameter name.

Definition at line 1408 of file InputParameters.C.

Referenced by getCommandLineArgumentType(), and getCommandLineSyntax().

1409 {
1410  const auto & cl_data = at(checkForRename(name))._cl_data;
1411  if (!cl_data)
1412  mooseError("The parameter '", name, "' is not a command line parameter.");
1413  return *cl_data;
1414 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::optional< CommandLineMetadata > _cl_data
The data pertaining to a command line parameter (empty if not a command line param) ...
Metadata & at(const std::string &param_name)

◆ getCommandLineSyntax()

const std::vector< std::string > & InputParameters::getCommandLineSyntax ( const std::string &  name) const
Returns
The command line syntax for the parameter name

Definition at line 897 of file InputParameters.C.

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

898 {
899  return getCommandLineMetadata(name).syntax;
900 }
std::vector< std::string > syntax
The syntax for the parameter (i.e., ["-t", "--timing"])
const CommandLineMetadata & getCommandLineMetadata(const std::string &name) const

◆ getControllableExecuteOnTypes()

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

Return the allowed execute flags for a controllable parameter.

Definition at line 458 of file InputParameters.C.

459 {
460  const auto name = checkForRename(name_in);
461  return at(name)._controllable_flags;
462 }
std::string name(const ElemQuality q)
std::set< ExecFlagType > _controllable_flags
Controllable execute flag restriction.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
Metadata & at(const std::string &param_name)

◆ getControllableParameters()

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

Return list of controllable parameters.

Definition at line 1446 of file InputParameters.C.

Referenced by checkParams(), and get().

1447 {
1448  std::set<std::string> controllable;
1449  for (auto it = _params.begin(); it != _params.end(); ++it)
1450  if (it->second._controllable)
1451  controllable.emplace(it->first);
1452  return controllable;
1453 }
std::map< std::string, Metadata > _params
The actual parameter data.

◆ getCoupledVariableParamNames()

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

Return the coupled variable parameter names.

Definition at line 719 of file InputParameters.h.

719 { return _coupled_vars; }
std::set< std::string > _coupled_vars
The coupled variables set.

◆ getDescription()

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

Get the documentation string for a parameter.

Definition at line 1086 of file InputParameters.C.

Referenced by transferParam().

1087 {
1088  const auto name = checkForRename(name_in);
1089  auto it = _params.find(name);
1090  if (it == _params.end())
1091  mooseError("No parameter exists with the name ", name);
1092  return it->second._doc_string;
1093 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ getDocString()

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

Returns the documentation string for the specified parameter name.

Definition at line 328 of file InputParameters.C.

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

329 {
330  const auto name = checkForRename(name_in);
331 
332  std::string doc_string;
333  auto it = _params.find(name);
334  if (it != _params.end())
335  for (const auto & ch : it->second._doc_string)
336  {
337  if (ch == '\n')
338  doc_string += " ... ";
339  else
340  doc_string += ch;
341  }
342 
343  return doc_string;
344 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

910 {
911  const auto param_name = checkForRename(param_name_in);
912  auto it = _params.find(param_name);
913  if (it != _params.end())
914  return it->second._group;
915  return std::string();
916 }
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ getGroupParameters()

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

Return names of parameters within a group.

Definition at line 1427 of file InputParameters.C.

1428 {
1429  std::set<std::string> names;
1430  for (auto it = _params.begin(); it != _params.end(); ++it)
1431  if (it->second._group == group)
1432  names.emplace(it->first);
1433  return names;
1434 }
std::map< std::string, Metadata > _params
The actual parameter data.

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

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

1370 {
1371  return at(param)._hit_node;
1372 }
const hit::Node * _hit_node
Original location of parameter node; used for error messages.
Metadata & at(const std::string &param_name)

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

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

1075 { return _hit_node; }
const hit::Node * _hit_node
The hit node representing the syntax that created these parameters, if any.

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

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

805 {
806  const auto name = checkForRename(name_in);
807  std::string var;
808 
809  if (have_parameter<VariableName>(name))
810  var = get<VariableName>(name);
811  else if (have_parameter<NonlinearVariableName>(name))
812  var = get<NonlinearVariableName>(name);
813  else if (have_parameter<AuxVariableName>(name))
814  var = get<AuxVariableName>(name);
815  else if (have_parameter<PostprocessorName>(name))
816  var = get<PostprocessorName>(name);
817  else if (have_parameter<VectorPostprocessorName>(name))
818  var = get<VectorPostprocessorName>(name);
819  else if (have_parameter<FunctionName>(name))
820  var = get<FunctionName>(name);
821  else if (have_parameter<UserObjectName>(name))
822  var = get<UserObjectName>(name);
823  else if (have_parameter<MaterialPropertyName>(name))
824  var = get<MaterialPropertyName>(name);
825  else if (have_parameter<std::string>(name))
826  var = get<std::string>(name);
827 
828  return var;
829 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.

◆ getNewToDeprecatedVarMap()

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

Return the new to deprecated variable name map.

Definition at line 724 of file InputParameters.h.

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

◆ getParametersList()

std::set< std::string > InputParameters::getParametersList ( ) const
Returns
list of all parameters

Definition at line 1437 of file InputParameters.C.

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

1438 {
1439  std::set<std::string> param_set;
1440  for (auto it = _params.begin(); it != _params.end(); ++it)
1441  param_set.emplace(it->first);
1442  return param_set;
1443 }
std::map< std::string, Metadata > _params
The actual parameter data.

◆ getParamFileBase()

std::filesystem::path InputParameters::getParamFileBase ( const std::string &  param_name) const
Returns
A file base to associate with the parameter with name param_name.

We have the following cases:

  • 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 671 of file InputParameters.C.

Referenced by finalize().

672 {
673  mooseAssert(!have_parameter<std::string>("_app_name"),
674  "Not currently setup to work with app FileName parameters");
675 
676  // Context from the individual parameter
677  const hit::Node * hit_node = getHitNode(param_name);
678  // Context from the parameters
679  if (!hit_node)
680  hit_node = getHitNode();
681  // No hit node, so use the cwd (no input files)
682  if (!hit_node)
683  return std::filesystem::current_path();
684 
685  // Find any context that isn't command line arguments
686  while (hit_node && hit_node->filename() == "CLI_ARGS")
687  hit_node = hit_node->parent();
688 
689  // Failed to find a node up the tree that isn't a command line argument
690  if (!hit_node)
691  mooseError(
692  errorPrefix(param_name),
693  " Parameter was set via a command-line argument and does not have sufficient context for "
694  "determining a file path.");
695 
696  return std::filesystem::absolute(std::filesystem::path(hit_node->filename()).parent_path());
697 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string errorPrefix(const std::string &param) const
generate error message prefix with parameter name and location (if available)
const hit::Node * getHitNode() const

◆ getParamHelper() [1/5]

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

Definition at line 1900 of file InputParameters.h.

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

1904 {
1905  const auto name = pars.checkForRename(name_in);
1906 
1907  if (!pars.isParamValid(name))
1908  {
1909  std::stringstream err;
1910  err << "The parameter \"" << name << "\" is being retrieved before being set.";
1911  if (moose_base)
1912  callMooseErrorHelper(*moose_base, err.str());
1913  else
1914  mooseError(err.str());
1915  }
1916 
1917  return pars.get<T>(name);
1918 }
std::string name(const ElemQuality q)
OStreamProxy err
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
static void callMooseErrorHelper(const MooseBase &moose_base, const std::string &error)
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ getParamHelper() [2/5]

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

Definition at line 1314 of file InputParameters.C.

1318 {
1319  const auto name = pars.checkForRename(name_in);
1320  return pars.get<MooseEnum>(name);
1321 }
std::string name(const ElemQuality q)
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.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:31
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.

◆ getParamHelper() [3/5]

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

Definition at line 1325 of file InputParameters.C.

1329 {
1330  const auto name = pars.checkForRename(name_in);
1331  return pars.get<MultiMooseEnum>(name);
1332 }
std::string name(const ElemQuality q)
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...

◆ getParamHelper() [4/5]

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

◆ getParamHelper() [5/5]

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

◆ getSystemAttributeName()

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

Get the system attribute name if it was registered.

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

Definition at line 487 of file InputParameters.C.

Referenced by AttribSystem::initFrom().

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

◆ getVecMooseType()

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

Definition at line 832 of file InputParameters.C.

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

833 {
834  const auto name = checkForRename(name_in);
835  std::vector<std::string> svars;
836 
837  if (have_parameter<std::vector<VariableName>>(name))
838  {
839  std::vector<VariableName> vars = get<std::vector<VariableName>>(name);
840  std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
841  }
842  else if (have_parameter<std::vector<NonlinearVariableName>>(name))
843  {
844  std::vector<NonlinearVariableName> vars = get<std::vector<NonlinearVariableName>>(name);
845  std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
846  }
847  else if (have_parameter<std::vector<AuxVariableName>>(name))
848  {
849  std::vector<AuxVariableName> vars = get<std::vector<AuxVariableName>>(name);
850  std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
851  }
852  else if (have_parameter<std::vector<MaterialPropertyName>>(name))
853  {
854  std::vector<MaterialPropertyName> vars = get<std::vector<MaterialPropertyName>>(name);
855  std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
856  }
857  else if (have_parameter<std::vector<std::string>>(name))
858  {
859  std::vector<std::string> vars = get<std::vector<std::string>>(name);
860  std::copy(vars.begin(), vars.end(), std::back_inserter(svars));
861  }
862 
863  return svars;
864 }
std::string name(const ElemQuality q)
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.

◆ hasCoupledValue()

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

Return whether or not the coupled variable exists.

Parameters
coupling_nameThe 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 729 of file InputParameters.C.

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

730 {
731  return _coupled_vars.find(coupling_name) != _coupled_vars.end();
732 }
std::set< std::string > _coupled_vars
The coupled variables set.

◆ hasDefault()

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

Return whether a parameter has a default.

Definition at line 714 of file InputParameters.C.

Referenced by transferParam().

715 {
716  const auto name = checkForRename(param_name);
717  if (hasDefaultCoupledValue(name))
718  return true;
719  // If it has a default, it's already valid
720  else if (isParamSetByAddParam(name))
721  return true;
722  else if (isParamValid(name))
723  mooseError("No way to know if the parameter", param_name, "has a default");
724  else
725  return false;
726 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
bool isParamSetByAddParam(const std::string &name) const
Returns whether or not the parameter was set due to addParam.
bool hasDefaultCoupledValue(const std::string &coupling_name) const
Return whether or not the requested parameter has a default coupled value.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ hasDefaultCoupledValue()

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

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

Parameters
coupling_nameThe name of the coupling parameter to get the default value for.

Definition at line 735 of file InputParameters.C.

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

736 {
737  return _params.count(coupling_name) > 0 && _params.at(coupling_name)._have_coupled_default &&
738  _coupled_vars.count(coupling_name) > 0;
739 }
std::set< std::string > _coupled_vars
The coupled variables set.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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

Parameters
nameThe 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 1997 of file InputParameters.h.

Referenced by ActionWarehouse::addActionBlock(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addIndicator(), FEProblemBase::addInterfaceKernel(), MooseEigenSystem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addScalarKernel(), FEProblemBase::addTransfer(), MooseServer::addValuesToList(), Moose::Builder::buildFullTree(), Moose::Builder::buildJsonSyntaxTree(), Coupleable::checkVar(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FunctorInterface::deduceFunctorName(), MooseServer::getActionParameters(), MooseServer::getCompletionItemKind(), MaterialBase::getGenericZeroMaterialProperty(), MooseServer::getHoverDisplayText(), MaterialPropertyInterface::getMaterialPropertyName(), MooseServer::getObjectParameters(), getVecMooseType(), AdvancedOutput::initExecutionTypes(), AttribDisplaced::initFrom(), isParamValid(), MooseApp::MooseApp(), OutputOnWarehouse::OutputOnWarehouse(), DumpObjectsProblem::stringifyParameters(), transferParam(), BlockRestrictable::validParams(), and Moose::Builder::walkRaw().

1998 {
1999  const auto name = checkForRename(std::string(name_in));
2000 
2001  return Parameters::have_parameter<T>(name);
2002 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter 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 1747 of file InputParameters.h.

Referenced by AddElementalFieldAction::validParams().

1748 {
1749  const auto name = checkForRename(name_in);
1750  suppressParameter<T>(name);
1751  _params[name]._ignore = true;
1752 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

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

1385 {
1386  if (const auto hit_node = getHitNode(param))
1387  return hit_node->fileLocation(/* with_column = */ false);
1388  return "";
1389 }
const hit::Node * getHitNode() const

◆ isCommandLineParameter()

bool InputParameters::isCommandLineParameter ( const std::string &  name) const
Returns
Whether or not the parameter name is a command line parameter

Definition at line 891 of file InputParameters.C.

892 {
893  return at(checkForRename(name))._cl_data.has_value();
894 }
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::optional< CommandLineMetadata > _cl_data
The data pertaining to a command line parameter (empty if not a command line param) ...
Metadata & at(const std::string &param_name)

◆ isControllable()

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

Returns a Boolean indicating whether the specified parameter is controllable.

Definition at line 451 of file InputParameters.C.

Referenced by transferParam().

452 {
453  const auto name = checkForRename(name_in);
454  return _params.count(name) > 0 && _params.at(name)._controllable;
455 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ isFinalized()

bool InputParameters::isFinalized ( ) const
inline
Returns
Whether or not finalize() has been called

Definition at line 1088 of file InputParameters.h.

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

1088 { return _finalized; }
bool _finalized
Whether or not we&#39;ve called finalize() on these parameters yet.

◆ isParamDeprecated()

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

Returns True if the parameters is deprecated.

Definition at line 406 of file InputParameters.C.

407 {
408  const auto name = checkForRename(name_in);
409  return _params.count(name) > 0 && !_params.at(name)._deprecation_message.empty();
410 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ isParamRequired()

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

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

Definition at line 360 of file InputParameters.C.

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

361 {
362  const auto name = checkForRename(name_in);
363  return _params.count(name) > 0 && _params.at(name)._required;
364 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

Referenced by MultiApp::createApp(), hasDefault(), MooseApp::MooseApp(), PicardSolve::PicardSolve(), and Transient::Transient().

400 {
401  const auto name = checkForRename(name_in);
402  return _params.count(name) > 0 && _params.at(name)._set_by_add_param;
403 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ isParamSetByUser()

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

Method returns true if the parameter was by the user.

Parameters
nameThe parameter name

Definition at line 1072 of file InputParameters.C.

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

1073 {
1074  const auto name = checkForRename(name_in);
1075  if (!isParamValid(name))
1076  // if the parameter is invalid, it is for sure not set by the user
1077  return false;
1078  else
1079  // If the parameters is not located in the list, then it was set by the user
1080  // If the parameter is private, and present in global params, it is ignored, therefore not set
1081  return _params.count(name) > 0 && !_params.at(name)._set_by_add_param &&
1082  !_params.at(name)._is_private;
1083 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

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

Referenced by ElementIDOutputAction::act(), ReadExecutorParamsAction::act(), CreateExecutionerAction::act(), CreateProblemDefaultAction::act(), MeshOnlyAction::act(), SetupMeshAction::act(), AddVariableAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblem::addLineSearch(), MooseObjectWarehouseBase< Indicator >::addObject(), FEProblemBase::addObjectParamsHelper(), JsonSyntaxTree::addParameters(), FEProblemBase::addTransfer(), AddVariableAction::addVariable(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), applyParameter(), areAllRequiredParamsValid(), UserObjectInterface::castUserObject(), PostprocessorInterface::checkParam(), checkParams(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), Coupleable::coupledVectorTagValues(), AppFactory::createShared(), FunctorInterface::deduceFunctorName(), FileRangeBuilder::FileRangeBuilder(), GapValueAux::GapValueAux(), MooseServer::getCompletionItemKind(), MaterialPropertyInterface::getMaterialDataType(), MaterialPropertyInterface::getMaterialPropertyName(), getParamHelper(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), GhostingUserObject::GhostingUserObject(), hasDefault(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), isParamSetByUser(), MooseBaseParameterInterface::isParamValid(), MooseApp::isParamValid(), isValid(), LayeredBase::LayeredBase(), LayeredSideIntegralBase< SideIntegralVariableUserObject >::LayeredSideIntegralBase(), MaterialVectorPostprocessor::MaterialVectorPostprocessor(), MultiApp::MultiApp(), NodeFaceConstraint::NodeFaceConstraint(), ParsedMaterialBase::ParsedMaterialBase(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), ReporterInterface::possiblyCheckHasReporter(), PseudoTimestep::PseudoTimestep(), rangeCheck(), ReferenceResidualProblem::ReferenceResidualProblem(), RenameBoundaryGenerator::RenameBoundaryGenerator(), MooseMesh::setPartitioner(), MeshBaseImageSampler::setupImageSampler(), ImageSampler::setupImageSampler(), SetupMeshAction::setupMesh(), Moose::PetscSupport::storePetscOptions(), Moose::SlepcSupport::storeSolveType(), DumpObjectsProblem::stringifyParameters(), BoundaryRestrictableRequired::validParams(), BoundaryRestrictable::validParams(), Coupleable::vectorTagDofValueHelper(), Coupleable::vectorTagValueHelper(), MeshBaseImageSampler::vtkMagnitude(), ImageSampler::vtkMagnitude(), MeshBaseImageSampler::vtkThreshold(), and ImageSampler::vtkThreshold().

377 {
378  const auto name = checkForRename(name_in);
379  if (have_parameter<MooseEnum>(name))
380  return get<MooseEnum>(name).isValid();
381  else if (have_parameter<std::vector<MooseEnum>>(name))
382  {
383  for (auto it = get<std::vector<MooseEnum>>(name).begin();
384  it != get<std::vector<MooseEnum>>(name).end();
385  ++it)
386  if (!it->isValid())
387  return false;
388  return true;
389  }
390  else if (have_parameter<MultiMooseEnum>(name))
391  return get<MultiMooseEnum>(name).isValid();
392  else if (have_parameter<ExecFlagEnum>(name))
393  return get<ExecFlagEnum>(name).isValid();
394  else
395  return _params.count(name) > 0 && _params.at(name)._valid;
396 }
std::string name(const ElemQuality q)
void isValid(MooseObject *obj)
Definition: TheWarehouse.C:287
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ isPrivate()

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

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

Definition at line 422 of file InputParameters.C.

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

423 {
424  const auto name = checkForRename(name_in);
425  return _params.count(name) > 0 && _params.at(name)._is_private;
426 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ isRangeChecked()

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

Return whether a parameter has a range check.

Definition at line 700 of file InputParameters.C.

Referenced by transferParam().

701 {
702  const auto name = checkForRename(param_name);
703  return !_params.find(name)->second._range_function.empty();
704 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

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

1978 {
1979  const auto name = checkForRename(name_in);
1980 
1981  if (!_params.count(name))
1982  mooseError("Parameter \"", name, "\" is not valid.");
1983  return have_parameter<T>(name);
1984 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ makeParamNotRequired() [1/2]

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

Changes the parameter to not be required.

Parameters
nameThe parameter name

Definition at line 1768 of file InputParameters.h.

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

1769 {
1770  const auto name = checkForRename(name_in);
1771 
1772  if (!this->have_parameter<T>(name))
1773  mooseError("Unable to un-require nonexistent parameter: ", name);
1774 
1775  _params[name]._required = false;
1776 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

368 {
369  const auto name = checkForRename(name_in);
370 
371  if (_params.count(name))
372  _params[name]._required = false;
373 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ makeParamRequired()

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

Changes the parameter to be required.

Parameters
nameThe parameter name

Definition at line 1756 of file InputParameters.h.

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

1757 {
1758  const auto name = checkForRename(name_in);
1759 
1760  if (!this->have_parameter<T>(name))
1761  mooseError("Unable to require nonexistent parameter: ", name);
1762 
1763  _params[name]._required = true;
1764 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ markControlled()

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

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

◆ mooseObjectSyntaxVisibility() [1/2]

void InputParameters::mooseObjectSyntaxVisibility ( bool  visibility)

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

Definition at line 538 of file InputParameters.C.

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

539 {
540  _moose_object_syntax_visibility = visibility;
541 }
bool _moose_object_syntax_visibility
This parameter hides derived MOOSE object types from appearing in syntax dumps.

◆ mooseObjectSyntaxVisibility() [2/2]

bool InputParameters::mooseObjectSyntaxVisibility ( ) const

Definition at line 544 of file InputParameters.C.

545 {
547 }
bool _moose_object_syntax_visibility
This parameter hides derived MOOSE object types from appearing in syntax dumps.

◆ numberDefaultCoupledValues()

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

Get the number of defaulted coupled value entries.

Parameters
coupling_nameThe name of the coupling parameter to get the default value for.

Definition at line 767 of file InputParameters.C.

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

768 {
769  auto value_it = _params.find(coupling_name);
770  if (value_it == _params.end())
771  mooseError("Attempted to retrieve default value for coupled variable '",
772  coupling_name,
773  "' when none was provided.");
774  return value_it->second._coupled_default.size();
775 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::map< std::string, Metadata > _params
The actual parameter data.

◆ operator+=()

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

Definition at line 184 of file InputParameters.C.

185 {
186  Parameters::operator+=(rhs);
187 
188  // TODO: this is not a proper merge - if a particular parameter exists in both this and rhs,
189  // then we should actually smartly merge both metadata structs before storing in this.
190  for (auto it = rhs._params.begin(); it != rhs._params.end(); ++it)
191  _params[it->first] = it->second;
192 
193  _buildable_types.insert(
194  _buildable_types.end(), rhs._buildable_types.begin(), rhs._buildable_types.end());
195  _buildable_rm_types.insert(
196  _buildable_rm_types.end(), rhs._buildable_rm_types.begin(), rhs._buildable_rm_types.end());
197 
198  // Collapse nesting and moose object syntax hiding are not modified with +=
199  _coupled_vars.insert(rhs._coupled_vars.begin(), rhs._coupled_vars.end());
202 
204  rhs._old_to_new_name_and_dep.end());
205  _new_to_old_names.insert(rhs._new_to_old_names.begin(), rhs._new_to_old_names.end());
206  return *this;
207 }
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...
std::unordered_map< std::string, std::string > _new_to_deprecated_coupled_vars
A map from deprecated coupled variable names to the new blessed name.
std::set< std::string > _coupled_vars
The coupled variables set.
std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > _buildable_rm_types
The RelationshipManagers that this object may either build or require.
std::vector< std::string > _buildable_types
The parameter is used to restrict types that can be built.
std::map< std::string, Metadata > _params
The actual parameter data.
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 dep...

◆ operator=()

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

Definition at line 145 of file InputParameters.C.

146 {
147  // An error to help minimize the segmentation faults that occure when MooseObjects do not have the
148  // correct constructor
149  if (!rhs._allow_copy)
150  {
151  const std::string & name =
152  rhs.get<std::string>("_object_name"); // If _allow_parameter_copy is set then so is name
153  // (see InputParameterWarehouse::addInputParameters)
154  mooseError("Copying of the InputParameters object for the ",
155  name,
156  " object is not allowed.\n\nThe likely cause for this error ",
157  "is having a constructor that does not use a const reference, all constructors\nfor "
158  "MooseObject based classes should be as follows:\n\n",
159  " MyObject::MyObject(const InputParameters & parameters);");
160  }
161 
163 
164  _params = rhs._params;
165 
172  _allow_copy = rhs._allow_copy;
177  _hit_node = rhs._hit_node;
178  _finalized = rhs._finalized;
179 
180  return *this;
181 }
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...
std::string name(const ElemQuality q)
bool _allow_copy
A flag for toggling the error message in the copy constructor.
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
std::string _block_location
original location of input block (i.e. filename,linenum) - used for nice error messages.
std::unordered_map< std::string, std::string > _new_to_deprecated_coupled_vars
A map from deprecated coupled variable names to the new blessed name.
std::string _block_fullpath
full HIT path of the block from the input file - used for nice error messages.
bool _collapse_nesting
This parameter collapses one level of nesting in the syntax blocks.
infix_ostream_iterator< T, charT, traits > & operator=(T const &item)
Definition: InfixIterator.h:46
std::set< std::string > _coupled_vars
The coupled variables set.
std::vector< std::tuple< std::string, Moose::RelationshipManagerType, Moose::RelationshipManagerInputParameterCallback > > _buildable_rm_types
The RelationshipManagers that this object may either build or require.
bool _finalized
Whether or not we&#39;ve called finalize() on these parameters yet.
const hit::Node * _hit_node
The hit node representing the syntax that created these parameters, if any.
std::vector< std::string > _buildable_types
The parameter is used to restrict types that can be built.
bool _moose_object_syntax_visibility
This parameter hides derived MOOSE object types from appearing in syntax dumps.
std::map< std::string, Metadata > _params
The actual parameter data.
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 dep...

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

1598 {
1599  mooseAssert(_values.find(param_name) != _values.end(),
1600  "The parameter we are searching for aliases for should exist in our parameter map");
1601  std::vector<std::string> aliases = {param_name};
1602 
1603  for (const auto & pr : as_range(_new_to_old_names.equal_range(param_name)))
1604  aliases.push_back(pr.second);
1605 
1606  return aliases;
1607 }
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...
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)

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

Referenced by checkParams(), and errorPrefix().

1393 {
1394  if (const auto hit_node = getHitNode(param))
1395  return hit_node->fullpath();
1396  return "";
1397 }
const hit::Node * getHitNode() const

◆ paramSetByUser()

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

Deprecated method.

Use isParamSetByUser() instead.

Definition at line 1065 of file InputParameters.C.

1066 {
1067  mooseDeprecated("paramSetByUser() is deprecated. Use isParamSetByUser() instead.");
1068  return isParamSetByUser(name);
1069 }
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:313
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was by the user.

◆ rangeCheck() [1/2]

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

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

Returns
Boolean indicating whether range check exists

Definition at line 1434 of file InputParameters.h.

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

1438 {
1439  mooseAssert(param, "Parameter is NULL");
1440 
1441  if (!isParamValid(short_name) || _params[short_name]._range_function.empty())
1442  return;
1443 
1444  // Parse the expression
1446  if (fp.Parse(_params[short_name]._range_function, short_name) != -1) // -1 for success
1447  {
1448  oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
1449  return;
1450  }
1451 
1452  // ensure range-checked input file parameter comparison functions
1453  // do absolute floating point comparisons instead of using a default epsilon.
1454  auto tmp_eps = fp.epsilon();
1455  fp.setEpsilon(0);
1456  // We require a non-const value for the implicit upscaling of the parameter type
1457  std::vector<UP_T> value(1, param->set());
1458  UP_T result = fp.Eval(&value[0]);
1459  fp.setEpsilon(tmp_eps);
1460 
1461  if (fp.EvalError())
1462  {
1463  oss << "Error evaluating expression: " << _params[short_name]._range_function
1464  << "\nPerhaps you used the wrong variable name?\n";
1465  return;
1466  }
1467 
1468  if (!result)
1469  oss << "Range check failed for parameter " << full_name
1470  << "\n\tExpression: " << _params[short_name]._range_function << "\n\tValue: " << value[0]
1471  << '\n';
1472 }
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::map< std::string, Metadata > _params
The actual parameter data.
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

◆ rangeCheck() [2/2]

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

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

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

Definition at line 1321 of file InputParameters.h.

1325 {
1326  mooseAssert(param, "Parameter is NULL");
1327 
1328  if (!isParamValid(short_name) || _params[short_name]._range_function.empty())
1329  return;
1330 
1343  std::vector<std::string> vars;
1344  if (fp.ParseAndDeduceVariables(_params[short_name]._range_function, vars) != -1) // -1 for success
1345  {
1346  oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
1347  return;
1348  }
1349 
1350  // Fparser parameter buffer
1351  std::vector<UP_T> parbuf(vars.size());
1352 
1353  // parameter vector
1354  const std::vector<T> & value = param->set();
1355 
1356  // iterate over all vector values (maybe ;)
1357  bool need_to_iterate = false;
1358  unsigned int i = 0;
1359  do
1360  {
1361  // set parameters
1362  for (unsigned int j = 0; j < vars.size(); j++)
1363  {
1364  if (vars[j] == short_name)
1365  {
1366  if (value.size() == 0)
1367  {
1368  oss << "Range checking empty vector: " << _params[short_name]._range_function << '\n';
1369  return;
1370  }
1371 
1372  parbuf[j] = value[i];
1373  need_to_iterate = true;
1374  }
1375  else if (vars[j] == short_name + "_size")
1376  parbuf[j] = value.size();
1377  else
1378  {
1379  if (vars[j].substr(0, short_name.size() + 1) != short_name + "_")
1380  {
1381  oss << "Error parsing expression: " << _params[short_name]._range_function << '\n';
1382  return;
1383  }
1384  std::istringstream iss(vars[j]);
1385  iss.seekg(short_name.size() + 1);
1386 
1387  size_t index;
1388  if (iss >> index && iss.eof())
1389  {
1390  if (index >= value.size())
1391  {
1392  oss << "Error parsing expression: " << _params[short_name]._range_function
1393  << "\nOut of range variable " << vars[j] << '\n';
1394  return;
1395  }
1396  parbuf[j] = value[index];
1397  }
1398  else
1399  {
1400  oss << "Error parsing expression: " << _params[short_name]._range_function
1401  << "\nInvalid variable " << vars[j] << '\n';
1402  return;
1403  }
1404  }
1405  }
1406 
1407  // ensure range-checked input file parameter comparison functions
1408  // do absolute floating point comparisons instead of using a default epsilon.
1409  auto tmp_eps = fp.epsilon();
1410  fp.setEpsilon(0);
1411  UP_T result = fp.Eval(&parbuf[0]);
1412  fp.setEpsilon(tmp_eps);
1413 
1414  // test function using the parameters determined above
1415  if (fp.EvalError())
1416  {
1417  oss << "Error evaluating expression: " << _params[short_name]._range_function << '\n';
1418  return;
1419  }
1420 
1421  if (!result)
1422  {
1423  oss << "Range check failed for parameter " << full_name
1424  << "\n\tExpression: " << _params[short_name]._range_function << "\n";
1425  if (need_to_iterate)
1426  oss << "\t Component: " << i << '\n';
1427  }
1428 
1429  } while (need_to_iterate && ++i < value.size());
1430 }
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
std::map< std::string, Metadata > _params
The actual parameter data.
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.

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

Referenced by transferParam().

708 {
709  const auto name = checkForRename(param_name);
710  return _params.at(name)._range_function;
711 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

1466 {
1467  if (const auto hit_node = getHitNode(param))
1468  return hit_node->strVal();
1469  return "";
1470 }
const hit::Node * getHitNode() const

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

Referenced by Kernel::validParams(), VectorKernel::validParams(), LineSearch::validParams(), ArrayKernel::validParams(), BoundsBase::validParams(), Distribution::validParams(), Times::validParams(), Positions::validParams(), Problem::validParams(), ScalarKernelBase::validParams(), Constraint::validParams(), ADInterfaceKernelTempl< T >::validParams(), LayeredExtremumMaterialProperty::validParams(), MoosePartitioner::validParams(), TimeStepper::validParams(), NearestPointIntegralVariablePostprocessor::validParams(), EigenKernel::validParams(), Postprocessor::validParams(), Split::validParams(), RelationshipManager::validParams(), Damper::validParams(), Predictor::validParams(), FVKernel::validParams(), NodalKernelBase::validParams(), BoundaryCondition::validParams(), DiracKernelTempl< T >::validParams(), VectorPostprocessor::validParams(), Indicator::validParams(), InterfaceKernelTempl< T >::validParams(), MoosePreconditioner::validParams(), TimeIntegrator::validParams(), AuxScalarKernel::validParams(), MooseVariableBase::validParams(), MeshDivision::validParams(), DGKernelBase::validParams(), MeshGenerator::validParams(), Control::validParams(), Marker::validParams(), Action::validParams(), ScalarInitialCondition::validParams(), FVInitialConditionBase::validParams(), Reporter::validParams(), Executioner::validParams(), Function::validParams(), Output::validParams(), UserObject::validParams(), Sampler::validParams(), InitialConditionBase::validParams(), FVBoundaryCondition::validParams(), FVInterfaceKernel::validParams(), AuxKernelTempl< Real >::validParams(), MultiApp::validParams(), and Executor::validParams().

466 {
467  InputParameters::set<std::string>("_moose_base") = value;
468  _params["_moose_base"]._is_private = true;
469 }
std::map< std::string, Metadata > _params
The actual parameter data.

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

497 {
498  _buildable_types.clear();
499  MooseUtils::tokenize(names, _buildable_types, 1, " \t\n\v\f\r"); // tokenize on whitespace
500 }
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
Definition: MooseUtils.h:779
std::vector< std::string > _buildable_types
The parameter is used to restrict types that can be built.

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

Referenced by Distribution::validParams(), FVDirichletBCBase::validParams(), TimeStepper::validParams(), FVFluxBC::validParams(), FVElementalKernel::validParams(), FVFluxKernel::validParams(), UserObject::validParams(), Sampler::validParams(), and FVInterfaceKernel::validParams().

481 {
482  InputParameters::set<std::string>("_moose_warehouse_system_name") = value;
483  _params["_moose_warehouse_system_name"]._is_private = true;
484 }
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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_nameThe old name of the coupled variable
new_nameThe new name of the coupled variable
new_docstringThe new documentation string for the coupled variable

Definition at line 1564 of file InputParameters.C.

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

1567 {
1568  renameCoupledVarInternal(old_name, new_name, new_docstring, "");
1569 }
void renameCoupledVarInternal(const std::string &old_name, const std::string &new_name, const std::string &docstring, const std::string &removal_date)

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

Referenced by deprecateCoupledVar(), and renameCoupledVar().

1542 {
1543  auto coupled_vars_it = _coupled_vars.find(old_name);
1544  if (coupled_vars_it == _coupled_vars.end())
1545  mooseError("Requested to rename coupled variable '",
1546  old_name,
1547  "' but that coupled variable name doesn't exist in the parameters object.");
1548 
1549  _coupled_vars.insert(new_name);
1550  _coupled_vars.erase(coupled_vars_it);
1551 
1552  renameParamInternal(old_name, new_name, docstring, removal_date);
1553 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
void renameParamInternal(const std::string &old_name, const std::string &new_name, const std::string &docstring, const std::string &removal_date)
std::set< std::string > _coupled_vars
The coupled variables set.

◆ 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_nameThe old name of the parameter
new_nameThe new name of the parameter
new_docstringThe new documentation string for the parameter If left empty, uses the old docstring for the renamed parameter

Definition at line 1556 of file InputParameters.C.

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

1559 {
1560  renameParamInternal(old_name, new_name, new_docstring, "");
1561 }
void renameParamInternal(const std::string &old_name, const std::string &new_name, const std::string &docstring, const std::string &removal_date)

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

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

1508 {
1509  auto params_it = _params.find(old_name);
1510  if (params_it == _params.end())
1511  mooseError("Requested to rename parameter '",
1512  old_name,
1513  "' but that parameter name doesn't exist in the parameters object.");
1514 
1515  auto new_metadata = std::move(params_it->second);
1516  if (!docstring.empty())
1517  new_metadata._doc_string = docstring;
1518  else
1519  new_metadata._doc_string = params_it->second._doc_string;
1520  _params.emplace(new_name, std::move(new_metadata));
1521  _params.erase(params_it);
1522 
1523  auto values_it = _values.find(old_name);
1524  auto new_value = std::move(values_it->second);
1525  _values.emplace(new_name, std::move(new_value));
1526  _values.erase(values_it);
1527 
1528  std::string deprecation_message;
1529  if (!removal_date.empty())
1530  deprecation_message = "'" + old_name + "' has been deprecated and will be removed on " +
1531  removal_date + ". Please use '" + new_name + "' instead.";
1532 
1533  _old_to_new_name_and_dep.emplace(old_name, std::make_pair(new_name, deprecation_message));
1534  _new_to_old_names.emplace(new_name, old_name);
1535 }
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...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::map< std::string, Metadata > _params
The actual parameter data.
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 dep...

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

1344 {
1345  const auto name = checkForRename(name_in);
1346  auto it = _params.find(name);
1347  if (it == _params.end())
1348  return std::set<std::string>();
1349  return it->second._reserved_values;
1350 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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
nameThe name of the parameter to set
quiet_modeWhen 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 1292 of file InputParameters.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), ElementIDOutputAction::act(), AddICAction::act(), PartitionerAction::act(), AddFVICAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), AdaptivityAction::act(), SetupDebugAction::act(), AddTimeStepperAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SetupResidualDebugAction::act(), AddAuxKernelAction::act(), MaterialDerivativeTestAction::act(), SetAdaptivityOptionsAction::act(), CreateDisplacedProblemAction::act(), DisplayGhostingAction::act(), AddPeriodicBCAction::act(), MaterialOutputAction::act(), AddNodalNormalsAction::act(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), DiffusionFV::addFVBCs(), FEProblemBase::addFVInitialCondition(), DiffusionFV::addFVKernels(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), MooseEigenSystem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), DiffusionCG::addNonlinearVariables(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addScalarKernel(), AuxiliarySystem::addTimeIntegrator(), NonlinearSystemBase::addTimeIntegrator(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), SystemBase::addVariable(), FEProblemBase::addVariable(), FVFluxKernel::adjustRMGhostLayers(), MeshGeneratorSystem::appendMeshGenerator(), AStableDirk4::AStableDirk4(), ActionWarehouse::buildBuildableActions(), MooseObjectUnitTest::buildObjects(), OversampleOutput::cloneMesh(), CommonOutputAction::create(), MultiApp::createApp(), AppFactory::createAppShared(), AddVariableAction::createInitialConditionAction(), MooseApp::createMinimalApp(), AppFactory::createShared(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::getFunction(), MaterialOutputAction::getParams(), Moose::SlepcSupport::getSlepcValidParams(), AddElementalFieldAction::init(), Factory::initialize(), SetupMeshAction::modifyParamsForUseSplit(), MooseServer::parseDocumentForDiagnostics(), GlobalParamsAction::setDoubleIndexParam(), MeshGenerator::setHasGenerateData(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setInputParametersFEProblem(), GlobalParamsAction::setParam(), FVKernel::setRMParams(), GlobalParamsAction::setScalarParam(), GlobalParamsAction::setTripleIndexParam(), ReadExecutorParamsAction::setupAutoPreconditioning(), CreateExecutionerAction::setupAutoPreconditioning(), MooseApp::setupOptions(), GlobalParamsAction::setVectorParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), FVOneVarDiffusionInterface::validParams(), AddICAction::validParams(), InversePowerMethod::validParams(), NonlinearEigen::validParams(), ExternalProblem::validParams(), FVFunctorTimeKernel::validParams(), FVTimeKernel::validParams(), ADScalarTimeKernel::validParams(), GenericConstant2DArray::validParams(), GenericConstantArray::validParams(), AddFVICAction::validParams(), DiscreteElementUserObject::validParams(), GenericConstantVectorMaterialTempl< is_ad >::validParams(), NodalPatchRecoveryBase::validParams(), JSONOutput::validParams(), ElementQualityChecker::validParams(), ElementSubdomainModifier::validParams(), GapValueAux::validParams(), PenetrationAux::validParams(), CSVReaderVectorPostprocessor::validParams(), NodalSum::validParams(), FVFunctorDirichletBCTempl< is_ad >::validParams(), MassMatrix::validParams(), ProjectionAux::validParams(), TimeIntervalTimes::validParams(), WeightedGapAux::validParams(), ElemSideNeighborLayersGeomTester::validParams(), ElemSideNeighborLayersTester::validParams(), JSONFileReader::validParams(), PerfGraphOutput::validParams(), ReporterDebugOutput::validParams(), VTKOutput::validParams(), ExodusFileTimes::validParams(), SimulationTimes::validParams(), FilePositions::validParams(), InputPositions::validParams(), ProjectedStatefulMaterialNodalPatchRecoveryBase::validParams(), MultiAppPositions::validParams(), ReporterPositions::validParams(), ReporterTimes::validParams(), PseudoTimestep::validParams(), TimeKernel::validParams(), TransformedPositions::validParams(), PiecewiseConstantFromCSV::validParams(), MessageFromInput::validParams(), CSVFileTimes::validParams(), AddAuxKernelAction::validParams(), ODETimeKernel::validParams(), GhostingAux::validParams(), GhostEverything::validParams(), GhostHigherDLowerDPointNeighbors::validParams(), GhostLowerDElems::validParams(), AccumulateReporter::validParams(), ArrayTimeKernel::validParams(), FVMassMatrix::validParams(), VectorTimeKernel::validParams(), InputTimes::validParams(), FVAnisotropicDiffusion::validParams(), MeshGeneratorMesh::validParams(), ConvectiveFluxBC::validParams(), Console::validParams(), ControlOutput::validParams(), EigenDirichletBC::validParams(), Positions::validParams(), NodalNormalBC::validParams(), CoupledTiedValueConstraint::validParams(), EqualValueEmbeddedConstraint::validParams(), TiedValueConstraint::validParams(), ElementGroupCentroidPositions::validParams(), ElementCentroidPositions::validParams(), DistributedPositions::validParams(), InterfaceTimeKernel::validParams(), VectorMagnitudeFunctorMaterialTempl< is_ad >::validParams(), NodalNormalsEvaluator::validParams(), FunctorTimes::validParams(), FunctorElementalGradientAuxTempl< is_ad >::validParams(), ADTimeKernelValueTempl< T >::validParams(), ADTimeKernelTempl< T >::validParams(), NearestNodeDistanceAux::validParams(), ADTimeKernelGradTempl< T >::validParams(), GenericConstantRankTwoTensorTempl< is_ad >::validParams(), NodalL2Norm::validParams(), EigenArrayDirichletBC::validParams(), FunctorPositions::validParams(), GenericVectorFunctorMaterialTempl< is_ad >::validParams(), LeastSquaresFitHistory::validParams(), BlockWeightedPartitioner::validParams(), GenericFunctorGradientMaterialTempl< is_ad >::validParams(), GenericFunctorMaterialTempl< is_ad >::validParams(), DOFMapOutput::validParams(), NearestNodeValueAux::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), PerfGraphReporter::validParams(), VectorOfPostprocessors::validParams(), IntegratedBCBase::validParams(), AddOutputAction::validParams(), TagAuxBase< AuxKernel >::validParams(), ElementUOAux::validParams(), ReporterPointSource::validParams(), TimeNodalKernel::validParams(), MortarNodalAuxKernelTempl< ComputeValueType >::validParams(), InterfaceQpUserObjectBase::validParams(), MultiAppGeneralFieldNearestLocationTransfer::validParams(), NearestPointAverage::validParams(), MaterialPropertyDebugOutput::validParams(), GenericConstantMaterialTempl< is_ad >::validParams(), ElementVariablesDifferenceMax::validParams(), Exodus::validParams(), VariableResidualNormsDebugOutput::validParams(), FVDiffusion::validParams(), SinDirichletBC::validParams(), Postprocessor::validParams(), DistributedRectilinearMeshGenerator::validParams(), GhostingUserObject::validParams(), NearestRadiusLayeredAverage::validParams(), TwoMaterialPropertyInterface::validParams(), FVFluxBC::validParams(), PropertyReadFile::validParams(), KernelBase::validParams(), NodalBCBase::validParams(), ThreeMaterialPropertyInterface::validParams(), MultiAppUserObjectTransfer::validParams(), InterfaceKernelBase::validParams(), MultiAppTransfer::validParams(), InterfaceMaterial::validParams(), RadialAverage::validParams(), ProjectedStatefulMaterialNodalPatchRecoveryTempl< T, is_ad >::validParams(), SamplerBase::validParams(), MortarConsumerInterface::validParams(), Control::validParams(), Marker::validParams(), MortarConstraintBase::validParams(), Output::validParams(), UserObject::validParams(), Sampler::validParams(), Checkpoint::validParams(), FVInterfaceKernel::validParams(), AuxKernelTempl< Real >::validParams(), TopResidualDebugOutput::validParams(), MooseVariableFV< Real >::validParams(), MultiApp::validParams(), Moose::Builder::walkRaw(), and RelationshipManager::zeroLayerGhosting().

1293 {
1294  const auto name = checkForRename(name_in);
1295 
1296  checkParamName(name);
1297  checkConsistentType<T>(name);
1298 
1299  T & result = this->Parameters::set<T>(name);
1300 
1301  if (quiet_mode)
1302  _params[name]._set_by_add_param = true;
1303 
1304  setHelper<T>(name);
1305 
1306  return result;
1307 }
std::string name(const ElemQuality q)
void checkParamName(const std::string &name) const
Make sure the parameter name doesn&#39;t have any invalid characters.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

Definition at line 88 of file InputParameters.C.

Referenced by applyParameter().

89 {
90  const auto name = checkForRename(name_in);
91 
92  if (!inserted_only)
93  {
94  auto & metadata = _params[name];
101  metadata._set_by_add_param = false;
102 
103  // valid_params don't make sense for MooseEnums
104  if (!have_parameter<MooseEnum>(name) && !have_parameter<MultiMooseEnum>(name))
105  metadata._valid = true;
106  }
107 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ setDeprecatedVarDocString()

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

Private method for setting deprecated coupled variable documentation strings.

Definition at line 210 of file InputParameters.C.

Referenced by addCoupledVar().

212 {
213  auto coupled_vars_it = _new_to_deprecated_coupled_vars.find(new_name);
214  if (coupled_vars_it != _new_to_deprecated_coupled_vars.end())
215  {
216  auto params_it = _params.find(coupled_vars_it->second);
217  if (params_it == _params.end())
218  mooseError("There must have been a mistake in the construction of the new to deprecated "
219  "coupled vars map because the old name ",
220  coupled_vars_it->second,
221  " doesn't exist in the parameters data.");
222 
223  params_it->second._doc_string = doc_string;
224  }
225 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::unordered_map< std::string, std::string > _new_to_deprecated_coupled_vars
A map from deprecated coupled variable names to the new blessed name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ setDocString()

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

Set the doc string of a parameter.

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

Definition at line 347 of file InputParameters.C.

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

348 {
349  const auto name = checkForRename(name_in);
350 
351  auto it = _params.find(name);
352  if (it == _params.end())
353  mooseError("Unable to set the documentation string (using setDocString) for the \"",
354  name,
355  "\" parameter, the parameter does not exist.");
356  it->second._doc_string = doc;
357 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

1286 {
1287 }

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

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

1378 {
1379  mooseAssert(node.type() == hit::NodeType::Field, "Must be a field");
1380  at(param)._hit_node = &node;
1381 }
const hit::Node * _hit_node
Original location of parameter node; used for error messages.
Metadata & at(const std::string &param_name)

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

1083 { _hit_node = &node; }
const hit::Node * _hit_node
The hit node representing the syntax that created these parameters, if any.

◆ 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
nameThe name of the first parameter to set

Definition at line 1311 of file InputParameters.h.

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

1314 {
1315  this->set<T>(name) = value;
1316  this->setParameters(extra_input_parameters...);
1317 }
std::string name(const ElemQuality q)
void setParameters()
Method to terminate the recursive setParameters definition.

◆ setParameters() [2/2]

void InputParameters::setParameters ( )
inlineprivate

Method to terminate the recursive setParameters definition.

Definition at line 1097 of file InputParameters.h.

Referenced by setParameters().

1097 {}

◆ setParamHelper() [1/17]

template<typename T , typename S >
void InputParameters::setParamHelper ( const std::string &  name,
T &  l_value,
const S &  r_value 
)
private

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

Definition at line 1555 of file InputParameters.h.

Referenced by addParam().

1556 {
1557  l_value = r_value;
1558 }

◆ setParamHelper() [2/17]

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

Definition at line 1218 of file InputParameters.C.

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

◆ setParamHelper() [3/17]

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

Definition at line 1230 of file InputParameters.C.

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

◆ setParamHelper() [4/17]

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

Definition at line 1242 of file InputParameters.C.

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

◆ setParamHelper() [5/17]

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

Definition at line 1254 of file InputParameters.C.

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

◆ setParamHelper() [6/17]

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

Definition at line 1266 of file InputParameters.C.

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

◆ setParamHelper() [7/17]

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

Definition at line 1278 of file InputParameters.C.

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

◆ setParamHelper() [8/17]

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

Definition at line 1290 of file InputParameters.C.

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

◆ setParamHelper() [9/17]

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

Definition at line 1302 of file InputParameters.C.

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

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

Referenced by OutputInterface::validParams().

1337 {
1338  const auto name = checkForRename(name_in);
1339  _params[name]._reserved_values = reserved;
1340 }
std::string name(const ElemQuality q)
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

1418 {
1419  const auto name = checkForRename(name_in);
1420  auto it = _params.find(name);
1421  if (it != _params.end())
1422  return it->second._ignore;
1423  mooseError("Parameter ", name, " does not exist");
1424 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

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

Referenced by ExternalProblem::validParams(), DiscreteElementUserObject::validParams(), ElementSubdomainModifier::validParams(), CSVReaderVectorPostprocessor::validParams(), MassMatrix::validParams(), SideSetsFromNormalsGenerator::validParams(), MultiAppCloneReporterTransfer::validParams(), SideSetsBetweenSubdomainsGenerator::validParams(), DiffusionFV::validParams(), FVMassMatrix::validParams(), PseudoTimestep::validParams(), AccumulateReporter::validParams(), CentroidMultiApp::validParams(), SideSetsFromPointsGenerator::validParams(), QuadraturePointMultiApp::validParams(), ElementHCurlSemiError::validParams(), ElementHDivSemiError::validParams(), SideSetsFromBoundingBoxGenerator::validParams(), MultiAppGeneralFieldShapeEvaluationTransfer::validParams(), AllSideSetsByNormalsGenerator::validParams(), MultiAppGeneralFieldUserObjectTransfer::validParams(), CSV::validParams(), ParsedGenerateSideset::validParams(), ReporterPointSource::validParams(), SideSetsAroundSubdomainGenerator::validParams(), MortarNodalAuxKernelTempl< ComputeValueType >::validParams(), MultiAppGeneralFieldNearestLocationTransfer::validParams(), VariableResidualNormsDebugOutput::validParams(), NearestRadiusLayeredAverage::validParams(), MultiAppUserObjectTransfer::validParams(), and Marker::validParams().

1734 {
1735  const auto name = checkForRename(name_in);
1736  if (!this->have_parameter<T>(name))
1737  mooseError("Unable to suppress nonexistent parameter: ", name);
1738 
1739  auto & metadata = _params[name];
1740  metadata._required = false;
1741  metadata._is_private = true;
1742  metadata._controllable = false;
1743 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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_paramThe parameters list holding the param we would like to transfer
nameThe name of the parameter to transfer
new_descriptionA new description of the parameter. If unspecified, uses the source_params'

Definition at line 2006 of file InputParameters.h.

Referenced by DiffusionCG::validParams().

2010 {
2011  const auto name = source_params.checkForRename(std::string(name_in));
2012  const auto p_name = new_name.empty() ? name_in : new_name;
2013  if (!source_params.have_parameter<T>(name) && !source_params.hasCoupledValue(name))
2014  mooseError("The '",
2015  name_in,
2016  "' parameter could not be transferred because it does not exist with type '",
2017  MooseUtils::prettyCppType<T>(),
2018  "' in the source parameters");
2019  if (name != name_in)
2020  mooseWarning("The transferred parameter " + name_in + " is deprecated in favor of " + name +
2021  " in the source parameters. The new name should likely be used for the parameter "
2022  "transfer instead.");
2023  const std::string description =
2024  new_description.empty() ? source_params.getDescription(name) : new_description;
2025 
2026  if (source_params.isParamRequired(name))
2027  {
2028  // Check for a variable parameter
2029  if (source_params.hasCoupledValue(name))
2030  addRequiredCoupledVar(p_name, description);
2031  // Enums parameters have a default list of options
2032  else if constexpr (std::is_same_v<MooseEnum, T> || std::is_same_v<MultiMooseEnum, T>)
2033  addRequiredParam<T>(p_name, source_params.get<T>(name), description);
2034  else if (source_params.isRangeChecked(name))
2035  addRequiredRangeCheckedParam<T>(
2036  p_name, source_params.rangeCheckedFunction(name), description);
2037  else
2038  addRequiredParam<T>(p_name, description);
2039  }
2040  else
2041  {
2042  // Check for a variable parameter
2043  if (source_params.hasCoupledValue(name))
2044  {
2045  if (!source_params.hasDefaultCoupledValue(name))
2046  addCoupledVar(p_name, description);
2047  else if (source_params.numberDefaultCoupledValues(name) == 1)
2048  addCoupledVar(p_name, source_params.defaultCoupledValue(name), description);
2049  else
2050  {
2051  std::vector<Real> coupled_values;
2052  for (const auto i : make_range(source_params.numberDefaultCoupledValues(name)))
2053  coupled_values.push_back(source_params.defaultCoupledValue(name, i));
2054  addCoupledVar(p_name, coupled_values, description);
2055  }
2056  }
2057  else if (source_params.isRangeChecked(name))
2058  {
2059  if (source_params.hasDefault(name))
2060  addRangeCheckedParam<T>(p_name,
2061  source_params.get<T>(name),
2062  source_params.rangeCheckedFunction(name),
2063  description);
2064  else
2065  addRangeCheckedParam<T>(p_name, source_params.rangeCheckedFunction(name), description);
2066  }
2067  else if constexpr (std::is_same_v<MooseEnum, T> || std::is_same_v<MultiMooseEnum, T>)
2068  addParam<T>(p_name, source_params.get<T>(name), description);
2069  else
2070  {
2071  if (source_params.hasDefault(name))
2072  addParam<T>(p_name, source_params.get<T>(name), description);
2073  else
2074  addParam<T>(p_name, description);
2075  }
2076  }
2077 
2078  // Copy other attributes
2079  if (source_params.isPrivate(name))
2080  _params[p_name]._is_private = true;
2081  if (source_params.isControllable(name))
2082  _params[p_name]._controllable = true;
2083 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:296
void addCoupledVar(const std::string &name, const std::string &doc_string)
This method adds a coupled variable name pair.
void addRequiredCoupledVar(const std::string &name, const std::string &doc_string)
This method adds a coupled variable name pair.
IntRange< T > make_range(T beg, T end)
std::map< std::string, Metadata > _params
The actual parameter data.

◆ type()

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

Prints the type of the requested parameter by name.

Definition at line 790 of file InputParameters.C.

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

791 {
792  const auto name = checkForRename(name_in);
793  if (!_values.count(name))
794  mooseError("Parameter \"", name, "\" not found.\n\n", *this);
795 
796  if (_coupled_vars.find(name) != _coupled_vars.end())
797  return "std::vector<VariableName>";
798  else if (_params.count(name) > 0 && !_params.at(name)._custom_type.empty())
799  return _params.at(name)._custom_type;
800  return _values.at(name)->type();
801 }
std::string name(const ElemQuality q)
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::set< std::string > _coupled_vars
The coupled variables set.
std::string checkForRename(const std::string &name) const
Checks whether the provided name is a renamed parameter name.
std::map< std::string, Metadata > _params
The actual parameter data.

◆ 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_namethe name of the variable parameter, e.g. 'variable'
moose_object_with_var_param_namethe name of the moose object holding the variable parameter. Used for potential error messaging

Definition at line 1473 of file InputParameters.C.

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

1475 {
1476  // Try the scalar version first
1477  std::string variable_name = getMooseType(var_param_name);
1478  if (variable_name == "")
1479  {
1480  auto vec = getVecMooseType(var_param_name);
1481 
1482  // Catch the (very unlikely) case where a user specifies
1483  // variable = '' (the empty string)
1484  // in their input file. This could happen if e.g. something goes
1485  // wrong with dollar bracket expression expansion.
1486  if (vec.empty())
1487  mooseError("Error constructing object '",
1488  moose_object_with_var_param_name,
1489  "' while retrieving value for '",
1490  var_param_name,
1491  "' parameter! Did you forget to set '",
1492  var_param_name,
1493  "' or set it to '' (empty string) by accident?");
1494 
1495  // When using vector variables, we are only going to use the first one in the list at the
1496  // interface level...
1497  variable_name = vec[0];
1498  }
1499 
1500  return variable_name;
1501 }
std::string getMooseType(const std::string &name) const
Utility functions for retrieving one of the MooseTypes variables into the common "string" base class...
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
std::vector< std::string > getVecMooseType(const std::string &name) const

Friends And Related Function Documentation

◆ ActionWarehouse

friend class ActionWarehouse
friend

Definition at line 1280 of file InputParameters.h.

◆ emptyInputParameters

InputParameters emptyInputParameters ( )
friend

Definition at line 30 of file InputParameters.C.

31 {
32  InputParameters params;
33  return params;
34 }
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...

◆ InputParameterWarehouse

friend class InputParameterWarehouse
friend

Definition at line 1277 of file InputParameters.h.

◆ Parser

friend class Parser
friend

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

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

◆ _block_fullpath

std::string InputParameters::_block_fullpath
private

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

Definition at line 1216 of file InputParameters.h.

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

◆ _block_location

std::string InputParameters::_block_location
private

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

Definition at line 1213 of file InputParameters.h.

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

◆ _buildable_rm_types

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

The RelationshipManagers that this object may either build or require.

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

Definition at line 1240 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 1231 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 1227 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 1244 of file InputParameters.h.

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

◆ _coupled_vars

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

◆ _finalized

bool InputParameters::_finalized
private

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

Definition at line 1273 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 1270 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 1247 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 1257 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 1267 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 1263 of file InputParameters.h.

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

◆ _params

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

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

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


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