https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
BatchMeshGeneratorAction Class Reference

Action to generate batches of mesh generators from vectors of parameter values. More...

#include <BatchMeshGeneratorAction.h>

Inheritance diagram for BatchMeshGeneratorAction:
[legend]

Public Types

enum class  MultiBatchParamsMethod { corresponding , cartesian_product }
 
enum class  ParameterType {
  BOOL , REAL , SHORT , USHORT ,
  INT , UINT , LONG , ULONG ,
  LONGLONG , ULONGLONG , DOFIDTYPE , BDRYIDTYPE ,
  SDIDTYPE , STRING , SDNAME , BDRYNAME ,
  MGNAME , MFNAME , ENUM , REALVECTORVALUE ,
  POINT
}
 
using DataFileParameterType = DataFileName
 The parameter type this interface expects for a data file name.
 

Public Member Functions

 BatchMeshGeneratorAction (const InputParameters &params)
 
virtual void act () override final
 Method to add objects to the simulation or perform other setup tasks.
 
void timedAct ()
 The method called externally that causes the action to act()
 
virtual void addRelationshipManagers (Moose::RelationshipManagerType when_type)
 Method to add a relationship manager for the objects being added to the system.
 
MooseObjectName uniqueActionName () const
 The unique name for accessing input parameters of this action in the InputParameterWarehouse.
 
const std::string & specificTaskName () const
 
const std::set< std::string > & getAllTasks () const
 
void appendTask (const std::string &task)
 
MooseApp & getMooseApp () const
 Get the MooseApp this class is associated with.
 
const std::string & type () const
 Get the type of this class.
 
const std::string & name () const
 Get the name of the class.
 
std::string typeAndName () const
 Get the class's combined type and name; useful in error handling.
 
MooseObjectParameterName uniqueParameterName (const std::string &parameter_name) const
 
MooseObjectName uniqueName () const
 
const InputParameters & parameters () const
 Get the parameters of the object.
 
const hit::Node * getHitNode () const
 
bool hasBase () const
 
const std::string & getBase () const
 
template<typename T >
const T & getParam (const std::string &name) const
 Retrieve a parameter for the object.
 
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > getParam (const std::string &param1, const std::string &param2) const
 Retrieve two parameters and provide pair of parameters for the object.
 
template<typename T >
const T * queryParam (const std::string &name) const
 Query a parameter for the object.
 
template<typename T >
const T & getRenamedParam (const std::string &old_name, const std::string &new_name) const
 Retrieve a renamed parameter for the object.
 
template<typename T >
T getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
 Verifies that the requested parameter exists and is not NULL and returns it to the caller.
 
bool isParamValid (const std::string &name) const
 Test if the supplied parameter is valid.
 
bool isParamSetByUser (const std::string &name) const
 Test if the supplied parameter is set by a user, as opposed to not set or set to default.
 
void connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
 Connect controllable parameter of this action with the controllable parameters of the objects added by this action.
 
template<typename... Args>
void paramError (const std::string &param, Args... args) const
 Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
 
template<typename... Args>
void paramWarning (const std::string &param, Args... args) const
 Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
 
template<typename... Args>
void paramWarning (const std::string &param, Args... args) const
 
template<typename... Args>
void paramInfo (const std::string &param, Args... args) const
 Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
 
std::string messagePrefix (const bool hit_prefix=true) const
 
std::string errorPrefix (const std::string &) const
 Deprecated message prefix; the error type is no longer used.
 
template<typename... Args>
void mooseError (Args &&... args) const
 Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.
 
template<typename... Args>
void mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
 
template<typename... Args>
void mooseErrorNonPrefixed (Args &&... args) const
 Emits an error without the prefixing included in mooseError().
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 Emits a warning prefixed with object name and type.
 
template<typename... Args>
void mooseWarning (Args &&... args) const
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 Emits a warning without the prefixing included in mooseWarning().
 
template<typename... Args>
void mooseWarningNonPrefixed (Args &&... args) const
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 Emits a deprecation warning prefixed with the object name and type, and a stack trace.
 
template<typename... Args>
void mooseDeprecated (Args &&... args) const
 
template<typename... Args>
void mooseDeprecatedNoTrace (Args &&... args) const
 Emits a deprecation warning prefixed with the object name and type, and no stack trace.
 
template<typename... Args>
void mooseInfo (Args &&... args) const
 
void callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
 External method for calling moose error with added object context.
 
const Parallel::Communicator & comm () const
 
processor_id_type n_processors () const
 
processor_id_type processor_id () const
 
std::string getDataFileName (const std::string &param) const
 Deprecated method.
 
std::string getDataFileNameByName (const std::string &relative_path) const
 Deprecated method.
 
std::string getDataFilePath (const std::string &relative_path) const
 Returns the path of a data file for a given relative file path.
 
PerfGraph & perfGraph ()
 Get the PerfGraph.
 
void assertParamDefined (const std::string &libmesh_dbg_var(param)) const
 

Static Public Member Functions

static InputParameters validParams ()
 
static void callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
 External method for calling moose error with added object context.
 

Public Attributes

 usingCombinedWarningSolutionWarnings
 
const ConsoleStream _console
 An instance of helper class to write streams to the Console objects.
 

Static Public Attributes

static const std::string unique_action_name_param = "_unique_action_name"
 The name of the parameter that contains the unique action name.
 
static const std::string type_param = "_type"
 The name of the parameter that contains the object type.
 
static const std::string name_param = "_object_name"
 The name of the parameter that contains the object name.
 
static const std::string unique_name_param = "_unique_name"
 The name of the parameter that contains the unique object name.
 
static const std::string app_param = "_moose_app"
 The name of the parameter that contains the MooseApp.
 
static const std::string moose_base_param = "_moose_base"
 The name of the parameter that contains the moose system base.
 
static const std::string kokkos_object_param = "_kokkos_object"
 The name of the parameter that indicates an object is a Kokkos functor.
 
static constexpr auto SYSTEM = "MeshMetaData"
 The system name used when initializing the Restartable interface.
 
static constexpr auto NAME = "<empty>"
 The data name used when initializing the Restartable interface for non-MeshGenerator objects.
 

Protected Member Functions

virtual void addMeshGenerators ()
 
void setScalarParams (InputParameters &params, const std::string &param_name, const ParameterType &param_type, const std::string &param_value) const
 Set the scalar input parameters for a unit mesh generator.
 
void setVectorParams (InputParameters &params, const std::string &param_name, const ParameterType &param_type, const std::vector< std::string > &param_value) const
 Set the vector input parameters for a unit mesh generator.
 
template<typename T >
void convertAndSetNumericVector (InputParameters &params, const std::string &param_name, const std::vector< std::string > &param_value) const
 Convert a vector of strings to a numeric vector and set it in the InputParameters object.
 
template<typename T >
void convertAndSetCompoundRealScalarVector (InputParameters &params, const std::string &param_name, const std::vector< std::string > &param_value) const
 Convert a vector of strings to a compound real scalar type vector and set it in the InputParameters object.
 
template<typename T >
void convertAndSetStringLikeVector (InputParameters &params, const std::string &param_name, const std::vector< std::string > &param_value) const
 Convert a vector of strings to a string-derived type vector and set it in the InputParameters object.
 
void checkInputParametersTypes (const InputParameters &params, const std::string &action_input_param_name, const std::vector< std::string > &param_names, const std::vector< ParameterType > &param_types, const bool &is_vector=false) const
 Check the types of the input parameters are valid, otherwise throw an error.
 
template<typename T >
void checkInputParameterType (const InputParameters &params, const std::string &action_input_param_name, const std::string &param_name, const bool &is_vector) const
 Check the type of the input parameter is valid, otherwise throw an error.
 
template<typename T >
T convertStringToCompoundRealScalar (const std::string &str) const
 Convert a string to a compound real scalar type.
 
bool isCompoundRealScalarType (const ParameterType &param_type) const
 Check if the parameter type is a compound real scalar type.
 
bool addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)
 Method to add a relationship manager for the objects being added to the system.
 
void associateWithParameter (const std::string &param_name, InputParameters &params) const
 Associates the object's parameters params with the input location from this Action's parameter with the name param_name, if one exists.
 
void associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const
 The same as associateWithParameter() without from_params, but instead allows you to associate this with another object's parameters instead of the parameters from this action.
 
template<typename T >
const T & getMeshProperty (const std::string &data_name, const std::string &prefix)
 Method for retrieving a property with the given type and name exists in the mesh meta-data store.
 
template<typename T >
const T & getMeshProperty (const std::string &data_name)
 
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
template<typename T >
bool hasMeshProperty (const std::string &data_name, const std::string &prefix) const
 
bool hasMeshProperty (const std::string &data_name) const
 
template<typename T >
bool hasMeshProperty (const std::string &data_name) const
 
std::string meshPropertyName (const std::string &data_name) const
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level) const
 Call to register a named section for timing.
 
PerfID registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
 Call to register a named section for timing.
 
std::string timedSectionName (const std::string &section_name) const
 
template<bool warning>
void flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
 Set solution invalid mark for the given solution ID.
 
InvalidSolutionID registerInvalidSolutionInternal (const std::string &message, const bool warning) const
 
void assertParamDefined (const std::string &param) const
 Check in debug mode that this parameter has been added to the validParams.
 
void checkParamsBothSetOrNotSet (const std::string &param1, const std::string &param2) const
 Check that two parameters are either both set or both not set.
 
void checkSecondParamSetOnlyIfFirstOneTrue (const std::string &param1, const std::string &param2) const
 Check that a parameter is set only if the first one is set to true.
 
void checkSecondParamSetOnlyIfFirstOneSet (const std::string &param1, const std::string &param2) const
 Check that a parameter is set only if the first one is set.
 
void checkSecondParamNotSetIfFirstOneSet (const std::string &param1, const std::string &param2) const
 Check that a parameter is not set if the first one is set.
 
void checkVectorParamsSameLength (const std::string &param1, const std::string &param2) const
 Check that the two vector parameters are of the same length.
 
void checkVectorParamAndMultiMooseEnumLength (const std::string &param1, const std::string &param2) const
 Check that this vector parameter (with name defined in param1) has the same length as the MultiMooseEnum (with name defined in param2)
 
void checkTwoDVectorParamsSameLength (const std::string &param1, const std::string &param2) const
 Check that the two-D vectors have exactly the same length in both dimensions.
 
void checkVectorParamsNoOverlap (const std::vector< std::string > &param_vecs) const
 Check that there is no overlap between the items in each vector parameters Each vector parameter should also have unique items.
 
void checkTwoDVectorParamsNoRespectiveOverlap (const std::vector< std::string > &param_vecs) const
 Check that there is no overlap between the respective items in each vector of the two-D parameters Each vector of the two-D vector parameter should also have unique items.
 
void checkTwoDVectorParamInnerSameLengthAsOneDVector (const std::string &param1, const std::string &param2) const
 Check that each inner vector of a two-D vector parameter are the same size as another one-D vector parameter.
 
void checkTwoDVectorParamMultiMooseEnumSameLength (const std::string &param1, const std::string &param2, const bool error_for_param2) const
 Check that the size of a two-D vector parameter matches the size of a MultiMooseEnum parameter.
 
void checkVectorParamNotEmpty (const std::string &param1) const
 Check that the user did not pass an empty vector.
 
void checkVectorParamsSameLengthIfSet (const std::string &param1, const std::string &param2, const bool ignore_empty_default_param2=false) const
 Check that two vector parameters are the same length if both are set.
 
void checkVectorParamLengthSameAsCombinedOthers (const std::string &param1, const std::string &param2, const std::string &param3) const
 Check that a vector parameter is the same length as two others combined.
 
void checkBlockwiseConsistency (const std::string &block_param_name, const std::vector< std::string > &parameter_names) const
 Check if the user commited errors during the definition of block-wise parameters.
 
bool parameterConsistent (const InputParameters &other_param, const std::string &param_name) const
 Return whether two parameters are consistent.
 
void warnInconsistent (const InputParameters &parameters, const std::string &param_name) const
 Emits a warning if two parameters are not equal to each other.
 
void errorDependentParameter (const std::string &param1, const std::string &value_not_set, const std::vector< std::string > &dependent_params) const
 Error messages for parameters that should depend on another parameter.
 
void errorInconsistentDependentParameter (const std::string &param1, const std::string &value_set, const std::vector< std::string > &dependent_params) const
 Error messages for parameters that should depend on another parameter but with a different error message.
 

Static Protected Member Functions

static std::string meshPropertyName (const std::string &data_name, const std::string &prefix)
 

Protected Attributes

const std::string _mesh_generator_type
 Type (object name) of the mesh generator to use for batch generation.
 
const std::string _mesh_name_prefix
 Prefix to use for naming the batch generated meshes.
 
const std::vector< std::string > _batch_scalar_input_param_names
 Names of the scalar input parameters to vary in the batch generation.
 
const std::vector< ParameterType > _batch_scalar_input_param_types
 Types of the scalar input parameters to vary in the batch generation.
 
std::vector< std::vector< std::string > > _batch_scalar_input_param_values
 Values of the scalar input parameters to vary in the batch generation.
 
const std::vector< std::string > _batch_vector_input_param_names
 Names of the vector input parameters to vary in the batch generation.
 
const std::vector< ParameterType > _batch_vector_input_param_types
 Types of the vector input parameters to vary in the batch generation.
 
std::vector< std::vector< std::vector< std::string > > > _batch_vector_input_param_values
 Values of the vector input parameters to vary in the batch generation.
 
const MultiBatchParamsMethod _multi_batch_params_method
 Method to use for generating the batch parameters.
 
const std::vector< std::string > _fixed_scalar_input_param_names
 Names of the vector input parameters to keep fixed in the batch generation.
 
const std::vector< ParameterType > _fixed_scalar_input_param_types
 Types of the vector input parameters to keep fixed in the batch generation.
 
std::vector< std::string > _fixed_scalar_input_param_values
 Values of the vector input parameters to keep fixed in the batch generation.
 
const std::vector< std::string > _fixed_vector_input_param_names
 Names of the vector input parameters to keep fixed in the batch generation.
 
const std::vector< ParameterType > _fixed_vector_input_param_types
 Types of the vector input parameters to keep fixed in the batch generation.
 
std::vector< std::vector< std::string > > _fixed_vector_input_param_values
 Values of the vector input parameters to keep fixed in the batch generation.
 
const bool _use_decomposed_index
 Flag to indicate if the decomposed index should be used in the mesh name.
 
std::string _registered_identifier
 
std::string _specific_task_name
 This member will only be populated if this Action instance is only designed to handle one task.
 
std::set< std::string > _all_tasks
 A list of all the tasks that this Action will satisfy.
 
ActionWarehouse & _awh
 Reference to ActionWarehouse where we store object build by actions.
 
const std::string & _current_task
 The current action (even though we have separate instances for each action)
 
std::shared_ptr< MooseMesh > & _mesh
 
std::shared_ptr< MooseMesh > & _displaced_mesh
 
std::shared_ptr< FEProblemBase > & _problem
 Convenience reference to a problem this action works on.
 
PerfID _act_timer
 Timers.
 
MooseApp & _app
 The MOOSE application this is associated with.
 
Factory & _factory
 The Factory associated with the MooseApp.
 
ActionFactory & _action_factory
 Builds Actions.
 
const std::string & _type
 The type of this class.
 
const std::string & _name
 The name of this class.
 
const InputParameters & _pars
 The object's parameters.
 
const Parallel::Communicator & _communicator
 
MooseApp & _pg_moose_app
 The MooseApp that owns the PerfGraph.
 
const std::string _prefix
 A prefix to use for all sections.
 

Private Member Functions

bool addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)
 Method for adding a single relationship manager.
 
virtual std::string meshPropertyPrefix (const std::string &data_name) const
 The default prefix to use for getting/seeing if mesh properties exist.
 
const RestartableDataValue & getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const
 Helper for getting a mesh property.
 
template<typename... Args>
void mooseErrorInternal (Args &&... args) const
 Helper for forwarding a mooseError to an object's mooseError if it is available (said error will provide more context: object name and type)
 
const T & forwardGetParam (const std::string &param_name) const
 Forwards parameter check to the class using this utility.
 
const InputParameters & forwardParameters () const
 Forwards obtaining parameters to the class using this utility.
 
bool forwardIsParamSetByUser (const std::string &param_name) const
 Forwards parameter check to the class using this utility.
 
bool forwardIsParamValid (const std::string &param_name) const
 Forwards parameter check to the class using this utility.
 
void forwardParamError (Args &&... args) const
 Forwards error to the class using this utility to get better error messages.
 
void forwardMooseError (Args &&... args) const
 Forwards error to the class using this utility to get better error messages.
 
void forwardMooseWarning (Args &&... args) const
 Forwards warning to the class using this utility to get better error messages.
 
const std::string & forwardType () const
 Get the type of the class using this utility.
 
virtual const std::string & forwardName () const
 Get the name of the class using this utility.
 
const std::vector< SubdomainName > & forwardBlocks () const
 Get the blocks for the class using this utility.
 

Static Private Member Functions

static const hit::Node * getHitNode (const InputParameters &params)
 Internal method for getting a hit node (if available) given a set of parameters.
 
static std::string messagePrefix (const InputParameters &params, const bool hit_prefix)
 Internal method for getting the message prefix for an object (object type, name, etc).
 

Private Attributes

const ParallelParamObject & _parent
 
MooseApp & _meta_data_app
 Reference to the application.
 
const MooseObject *const _meta_data_object
 The MooseObject (if any); used for better error handling.
 
const MooseBase & _si_moose_base
 The MooseBase that owns this interface.
 
const FEProblemBase * _si_problem
 A pointer to FEProblem base.
 
const BatchMeshGeneratorAction *const _customer_class
 

Detailed Description

Action to generate batches of mesh generators from vectors of parameter values.

Definition at line 20 of file BatchMeshGeneratorAction.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName
inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

Member Enumeration Documentation

◆ MultiBatchParamsMethod

enum class BatchMeshGeneratorAction::MultiBatchParamsMethod
strong
Enumerator
corresponding 
cartesian_product 

Definition at line 30 of file BatchMeshGeneratorAction.h.

31 {
32 corresponding,
33 cartesian_product
34 };

◆ ParameterType

enum class BatchMeshGeneratorAction::ParameterType
strong
Enumerator
BOOL 
REAL 
SHORT 
USHORT 
INT 
UINT 
LONG 
ULONG 
LONGLONG 
ULONGLONG 
DOFIDTYPE 
BDRYIDTYPE 
SDIDTYPE 
STRING 
SDNAME 
BDRYNAME 
MGNAME 
MFNAME 
ENUM 
REALVECTORVALUE 
POINT 

Definition at line 36 of file BatchMeshGeneratorAction.h.

37 {
38 BOOL,
39 REAL,
40 SHORT,
41 USHORT,
42 INT,
43 UINT,
44 LONG,
45 ULONG,
46 LONGLONG,
47 ULONGLONG,
48 DOFIDTYPE,
49 BDRYIDTYPE,
50 SDIDTYPE,
51 STRING,
52 SDNAME,
53 BDRYNAME,
54 MGNAME,
55 MFNAME,
56 ENUM,
57 REALVECTORVALUE,
58 POINT
59 };

Constructor & Destructor Documentation

◆ BatchMeshGeneratorAction()

BatchMeshGeneratorAction::BatchMeshGeneratorAction ( const InputParameters &  params)

The compound real scalar value type does not alter the length of 'batch_vector_input_param_values'

Definition at line 103 of file BatchMeshGeneratorAction.C.

104 : Action(params),
105 InputParametersChecksUtils<BatchMeshGeneratorAction>(this),
106 _mesh_generator_type(getParam<std::string>("mesh_generator_type")),
107 _mesh_name_prefix(getParam<std::string>("mesh_name_prefix")),
108 _batch_scalar_input_param_names(
109 getParam<std::vector<std::string>>("batch_scalar_input_param_names")),
110 _batch_scalar_input_param_types(isParamValid("batch_scalar_input_param_types")
111 ? getParam<MultiMooseEnum>("batch_scalar_input_param_types")
112 .template getSetValueIDs<ParameterType>()
113 : std::vector<ParameterType>()),
114 _batch_scalar_input_param_values(
115 getParam<std::vector<std::vector<std::string>>>("batch_scalar_input_param_values")),
116 _batch_vector_input_param_names(
117 getParam<std::vector<std::string>>("batch_vector_input_param_names")),
118 _batch_vector_input_param_types(isParamValid("batch_vector_input_param_types")
119 ? getParam<MultiMooseEnum>("batch_vector_input_param_types")
120 .template getSetValueIDs<ParameterType>()
121 : std::vector<ParameterType>()),
122 _batch_vector_input_param_values(getParam<std::vector<std::vector<std::vector<std::string>>>>(
123 "batch_vector_input_param_values")),
124 _multi_batch_params_method(getParam<MooseEnum>("multi_batch_params_method")
125 .template getEnum<MultiBatchParamsMethod>()),
126 _fixed_scalar_input_param_names(
127 getParam<std::vector<std::string>>("fixed_scalar_input_param_names")),
128 _fixed_scalar_input_param_types(isParamValid("fixed_scalar_input_param_types")
129 ? getParam<MultiMooseEnum>("fixed_scalar_input_param_types")
130 .template getSetValueIDs<ParameterType>()
131 : std::vector<ParameterType>()),
132 _fixed_scalar_input_param_values(
133 getParam<std::vector<std::string>>("fixed_scalar_input_param_values")),
134 _fixed_vector_input_param_names(
135 getParam<std::vector<std::string>>("fixed_vector_input_param_names")),
136 _fixed_vector_input_param_types(isParamValid("fixed_vector_input_param_types")
137 ? getParam<MultiMooseEnum>("fixed_vector_input_param_types")
138 .template getSetValueIDs<ParameterType>()
139 : std::vector<ParameterType>()),
140 _fixed_vector_input_param_values(
141 getParam<std::vector<std::vector<std::string>>>("fixed_vector_input_param_values")),
142 _use_decomposed_index(getParam<bool>("use_decomposed_index"))
143{
144 // Sanity check for the fixed input parameters
145 checkVectorParamAndMultiMooseEnumLength<std::string>("fixed_scalar_input_param_names",
146 "fixed_scalar_input_param_types");
147 const auto fixed_scalar_real_compound_num =
148 std::count_if(_fixed_scalar_input_param_types.begin(),
149 _fixed_scalar_input_param_types.end(),
150 [this](const ParameterType & type) { return isCompoundRealScalarType(type); });
151 if (fixed_scalar_real_compound_num > 0)
152 {
153 if (_fixed_scalar_input_param_types.size() +
154 (Moose::dim - 1) * fixed_scalar_real_compound_num !=
155 _fixed_scalar_input_param_values.size())
156 paramError("fixed_scalar_input_param_values",
157 "This parameter must have a size that is consistent with "
158 "fixed_scalar_input_param_names. Note that each REALVECTORVALUE or POINT type "
159 "parameter must be represented as ",
160 std::to_string(Moose::dim),
161 " separate values instead of 1.");
162 // Rearrange _fixed_scalar_input_param_values so that each compound real scalar value is in one
163 // single string
164 auto fixed_scalar_input_param_values_tmp(_fixed_scalar_input_param_values);
165 _fixed_scalar_input_param_values.resize(_fixed_scalar_input_param_types.size());
166 unsigned int raw_value_ct = 0;
167 for (const auto i : index_range(_fixed_scalar_input_param_types))
168 {
169 if (isCompoundRealScalarType(_fixed_scalar_input_param_types[i]))
170 {
171 // In that case, the string element needs to contain three elements separated by spaces
172 _fixed_scalar_input_param_values[i] = MooseUtils::join(
173 fixed_scalar_input_param_values_tmp.begin() + raw_value_ct,
174 fixed_scalar_input_param_values_tmp.begin() + raw_value_ct + Moose::dim,
175 " ");
176 raw_value_ct += Moose::dim;
177 }
178 else
179 {
180 _fixed_scalar_input_param_values[i] = fixed_scalar_input_param_values_tmp[raw_value_ct];
181 raw_value_ct += 1;
182 }
183 }
184 }
185 else
186 checkVectorParamsSameLength<std::string, std::string>("fixed_scalar_input_param_names",
187 "fixed_scalar_input_param_values");
188
189 checkVectorParamAndMultiMooseEnumLength<std::string>("fixed_vector_input_param_names",
190 "fixed_vector_input_param_types");
191 // The compound real scalar value type does not alter the length of
192 // 'fixed_vector_input_param_values'
193 checkVectorParamsSameLength<std::string, std::vector<std::string>>(
194 "fixed_vector_input_param_names", "fixed_vector_input_param_values");
195 // But we still need to process the affected elements
196 for (const auto i : index_range(_fixed_vector_input_param_types))
197 {
198 if (isCompoundRealScalarType(_fixed_vector_input_param_types[i]))
199 {
200 // Ensure that each compound real scalar value is represented as Moose::dim Real values
201 if (_fixed_vector_input_param_values[i].size() % Moose::dim != 0)
202 paramError("fixed_vector_input_param_values",
203 "This parameter must have a size that is consistent with "
204 "fixed_vector_input_param_names. Note that each REALVECTORVALUE or POINT type "
205 "parameter must be represented as ",
206 std::to_string(Moose::dim),
207 " separate values instead of 1.");
208 auto unit_fixed_vector_input_param_values_tmp(_fixed_vector_input_param_values[i]);
209 _fixed_vector_input_param_values[i].resize(unit_fixed_vector_input_param_values_tmp.size() /
210 Moose::dim);
211 for (const auto j : index_range(_fixed_vector_input_param_values[i]))
212 _fixed_vector_input_param_values[i][j] = MooseUtils::join(
213 unit_fixed_vector_input_param_values_tmp.begin() + j * Moose::dim,
214 unit_fixed_vector_input_param_values_tmp.begin() + j * Moose::dim + Moose::dim,
215 " ");
216 }
217 }
218
219 // Sanity check for the batch input parameters
220 checkVectorParamAndMultiMooseEnumLength<std::string>("batch_scalar_input_param_names",
221 "batch_scalar_input_param_types");
222 // The compound real scalar value type does not alter the length of
223 // 'batch_scalar_input_param_values'
224 checkVectorParamsSameLength<std::string, std::vector<std::string>>(
225 "batch_scalar_input_param_names", "batch_scalar_input_param_values");
226 // But we still need to process the affected elements
227 for (const auto i : index_range(_batch_scalar_input_param_types))
228 {
229 if (isCompoundRealScalarType(_batch_scalar_input_param_types[i]))
230 {
231 // Ensure that each compound real scalar value is represented as Moose::dim Real values
232 if (_batch_scalar_input_param_values[i].size() % Moose::dim != 0)
233 paramError("batch_scalar_input_param_values",
234 "This parameter must have a size that is consistent with "
235 "batch_scalar_input_param_names. Note that each REALVECTORVALUE or POINT type "
236 "parameter must be represented as ",
237 std::to_string(Moose::dim),
238 " separate values instead of 1.");
239 auto unit_batch_scalar_input_param_values_tmp(_batch_scalar_input_param_values[i]);
240 _batch_scalar_input_param_values[i].resize(unit_batch_scalar_input_param_values_tmp.size() /
241 3);
242 for (const auto j : index_range(_batch_scalar_input_param_values[i]))
243 _batch_scalar_input_param_values[i][j] = MooseUtils::join(
244 unit_batch_scalar_input_param_values_tmp.begin() + j * Moose::dim,
245 unit_batch_scalar_input_param_values_tmp.begin() + j * Moose::dim + Moose::dim,
246 " ");
247 }
248 }
249
250 checkVectorParamAndMultiMooseEnumLength<std::string>("batch_vector_input_param_names",
251 "batch_vector_input_param_types");
253 checkVectorParamsSameLength<std::string, std::vector<std::vector<std::string>>>(
254 "batch_vector_input_param_names", "batch_vector_input_param_values");
255 // But we still need to process the affected elements
256 for (const auto i : index_range(_batch_vector_input_param_types))
257 {
258 if (isCompoundRealScalarType(_batch_vector_input_param_types[i]))
259 {
260 for (const auto j : index_range(_batch_vector_input_param_values[i]))
261 {
262 // Ensure that each compound real scalar value is represented as Moose::dim Real values
263 if (_batch_vector_input_param_values[i][j].size() % Moose::dim != 0)
264 paramError("batch_vector_input_param_values",
265 "This parameter must have a size that is consistent with "
266 "batch_vector_input_param_names. Note that each REALVECTORVALUE or POINT type "
267 "parameter must be represented as ",
268 Moose::dim,
269 " separate values instead of 1.");
270 auto unit_batch_vector_input_param_values_tmp(_batch_vector_input_param_values[i][j]);
271 _batch_vector_input_param_values[i][j].resize(
272 unit_batch_vector_input_param_values_tmp.size() / 3);
273 for (const auto k : index_range(_batch_vector_input_param_values[i][j]))
274 _batch_vector_input_param_values[i][j][k] = MooseUtils::join(
275 unit_batch_vector_input_param_values_tmp.begin() + k * Moose::dim,
276 unit_batch_vector_input_param_values_tmp.begin() + k * Moose::dim + Moose::dim,
277 " ");
278 }
279 }
280 }
281
282 // At least we want this action to create one mesh generator
283 if (_batch_scalar_input_param_names.empty() && _batch_vector_input_param_names.empty())
284 mooseError("BatchMeshGeneratorAction: " + _name +
285 ", batch_scalar_input_param_names and batch_vector_input_param_names cannot be "
286 "empty at the same time.");
287
288 // If the previous check is passed, batch_params_sizes will not be empty
289 // But we need to check if any element of the batch_params_values are empty
290 std::set<unsigned int> batch_params_sizes;
291 for (const auto & unit_batch_scalar_param_values : _batch_scalar_input_param_values)
292 {
293 if (unit_batch_scalar_param_values.empty())
294 paramError("batch_scalar_input_param_values",
295 "this parameter cannot contain empty elements.");
296 batch_params_sizes.emplace(unit_batch_scalar_param_values.size());
297 }
298 for (const auto & unit_batch_vector_param_values : _batch_vector_input_param_values)
299 {
300 if (unit_batch_vector_param_values.empty())
301 paramError("batch_vector_input_param_values",
302 "this parameter cannot contain empty elements.");
303 batch_params_sizes.emplace(unit_batch_vector_param_values.size());
304 }
305
306 // Then for the corresponding method, the sizes of the batch_params_values should be the same
307 if (_multi_batch_params_method == MultiBatchParamsMethod::corresponding &&
308 batch_params_sizes.size() > 1)
309 mooseError("BatchMeshGeneratorAction: " + _name +
310 ", elements of batch_scalar_input_param_values and batch_vector_input_param_values "
311 "must have the same size in corresponding mode.");
312
313 // Decomposed index cannot be used with the corresponding method
314 if (_use_decomposed_index && _multi_batch_params_method == MultiBatchParamsMethod::corresponding)
315 paramError("use_decomposed_index",
316 "Decomposed index cannot be used with the corresponding method.");
317 // Check the parameter types are given correctly here so that we do not need to do it when setting
318 // the values.
319 auto set_params = _app.getFactory().getValidParams(_mesh_generator_type);
320 // batch scalar input parameters
321 checkInputParametersTypes(set_params,
322 "batch_scalar_input_param_names",
323 _batch_scalar_input_param_names,
324 _batch_scalar_input_param_types);
325 // fix scalar input parameters
326 checkInputParametersTypes(set_params,
327 "fixed_scalar_input_param_names",
328 _fixed_scalar_input_param_names,
329 _fixed_scalar_input_param_types);
330 // batch vector input parameters
331 checkInputParametersTypes(set_params,
332 "batch_vector_input_param_names",
333 _batch_vector_input_param_names,
334 _batch_vector_input_param_types,
335 true);
336 // fix vector input parameters
337 checkInputParametersTypes(set_params,
338 "fixed_vector_input_param_names",
339 _fixed_vector_input_param_names,
340 _fixed_vector_input_param_types,
341 true);
342}
dim
unsigned int dim
Action
Base class for actions.
Definition Action.h:38
Action::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition MooseBase.h:375
BatchMeshGeneratorAction::_fixed_vector_input_param_values
std::vector< std::vector< std::string > > _fixed_vector_input_param_values
Values of the vector input parameters to keep fixed in the batch generation.
Definition BatchMeshGeneratorAction.h:92
BatchMeshGeneratorAction::_fixed_scalar_input_param_types
const std::vector< ParameterType > _fixed_scalar_input_param_types
Types of the vector input parameters to keep fixed in the batch generation.
Definition BatchMeshGeneratorAction.h:84
BatchMeshGeneratorAction::_batch_scalar_input_param_values
std::vector< std::vector< std::string > > _batch_scalar_input_param_values
Values of the scalar input parameters to vary in the batch generation.
Definition BatchMeshGeneratorAction.h:72
BatchMeshGeneratorAction::_fixed_vector_input_param_names
const std::vector< std::string > _fixed_vector_input_param_names
Names of the vector input parameters to keep fixed in the batch generation.
Definition BatchMeshGeneratorAction.h:88
BatchMeshGeneratorAction::_mesh_generator_type
const std::string _mesh_generator_type
Type (object name) of the mesh generator to use for batch generation.
Definition BatchMeshGeneratorAction.h:64
BatchMeshGeneratorAction::isCompoundRealScalarType
bool isCompoundRealScalarType(const ParameterType &param_type) const
Check if the parameter type is a compound real scalar type.
Definition BatchMeshGeneratorAction.C:961
BatchMeshGeneratorAction::_mesh_name_prefix
const std::string _mesh_name_prefix
Prefix to use for naming the batch generated meshes.
Definition BatchMeshGeneratorAction.h:66
BatchMeshGeneratorAction::_multi_batch_params_method
const MultiBatchParamsMethod _multi_batch_params_method
Method to use for generating the batch parameters.
Definition BatchMeshGeneratorAction.h:80
BatchMeshGeneratorAction::_batch_vector_input_param_names
const std::vector< std::string > _batch_vector_input_param_names
Names of the vector input parameters to vary in the batch generation.
Definition BatchMeshGeneratorAction.h:74
BatchMeshGeneratorAction::_fixed_scalar_input_param_names
const std::vector< std::string > _fixed_scalar_input_param_names
Names of the vector input parameters to keep fixed in the batch generation.
Definition BatchMeshGeneratorAction.h:82
BatchMeshGeneratorAction::_batch_scalar_input_param_types
const std::vector< ParameterType > _batch_scalar_input_param_types
Types of the scalar input parameters to vary in the batch generation.
Definition BatchMeshGeneratorAction.h:70
BatchMeshGeneratorAction::_fixed_vector_input_param_types
const std::vector< ParameterType > _fixed_vector_input_param_types
Types of the vector input parameters to keep fixed in the batch generation.
Definition BatchMeshGeneratorAction.h:90
BatchMeshGeneratorAction::_batch_vector_input_param_values
std::vector< std::vector< std::vector< std::string > > > _batch_vector_input_param_values
Values of the vector input parameters to vary in the batch generation.
Definition BatchMeshGeneratorAction.h:78
BatchMeshGeneratorAction::_batch_vector_input_param_types
const std::vector< ParameterType > _batch_vector_input_param_types
Types of the vector input parameters to vary in the batch generation.
Definition BatchMeshGeneratorAction.h:76
BatchMeshGeneratorAction::_fixed_scalar_input_param_values
std::vector< std::string > _fixed_scalar_input_param_values
Values of the vector input parameters to keep fixed in the batch generation.
Definition BatchMeshGeneratorAction.h:86
BatchMeshGeneratorAction::checkInputParametersTypes
void checkInputParametersTypes(const InputParameters &params, const std::string &action_input_param_name, const std::vector< std::string > &param_names, const std::vector< ParameterType > &param_types, const bool &is_vector=false) const
Check the types of the input parameters are valid, otherwise throw an error.
Definition BatchMeshGeneratorAction.C:832
BatchMeshGeneratorAction::_batch_scalar_input_param_names
const std::vector< std::string > _batch_scalar_input_param_names
Names of the scalar input parameters to vary in the batch generation.
Definition BatchMeshGeneratorAction.h:68
BatchMeshGeneratorAction::_use_decomposed_index
const bool _use_decomposed_index
Flag to indicate if the decomposed index should be used in the mesh name.
Definition BatchMeshGeneratorAction.h:94
Factory::getValidParams
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition Factory.C:68
InputParametersChecksUtils
Utility class to help check parameters.
Definition InputParametersChecksUtils.h:28
MooseApp::getFactory
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition MooseApp.h:407
MooseBase::type
const std::string & type() const
Get the type of this class.
Definition MooseBase.h:93
MooseBase::paramError
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
Definition MooseBase.h:457
MooseBase::mooseError
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type and optionally a file path to the top-level block p...
Definition MooseBase.h:271
MooseBase::_name
const std::string & _name
The name of this class.
Definition MooseBase.h:381
MooseBase::getParam
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition MooseBase.h:406
MooseBase::isParamValid
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition MooseBase.h:199
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition MooseEnum.h:55
MultiMooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type.
Definition MultiMooseEnum.h:42
Moose
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
Definition SetAdaptivityOptionsAction.h:15
Moose::dim
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition Moose.h:165
libMesh::index_range
auto index_range(const T &sizable)

Member Function Documentation

◆ act()

void BatchMeshGeneratorAction::act ( )
finaloverridevirtual

Method to add objects to the simulation or perform other setup tasks.

Implements Action.

Definition at line 345 of file BatchMeshGeneratorAction.C.

346{
347 if (_current_task == "add_mesh_generator")
348 addMeshGenerators();
349}
Action::_current_task
const std::string & _current_task
The current action (even though we have separate instances for each action)
Definition Action.h:172

◆ addMeshGenerators()

void BatchMeshGeneratorAction::addMeshGenerators ( )
protectedvirtual

Definition at line 352 of file BatchMeshGeneratorAction.C.

353{
354 std::vector<std::vector<std::string>> processed_batch_scalar_input_param_values;
355 std::vector<std::vector<std::vector<std::string>>> processed_batch_vector_input_param_values;
356 // generate the decomposed indices for the cartesian product method
357 std::vector<std::vector<unsigned int>> processed_batch_indices;
358 if (_multi_batch_params_method == MultiBatchParamsMethod::corresponding)
359 {
360 processed_batch_scalar_input_param_values = _batch_scalar_input_param_values;
361 processed_batch_vector_input_param_values = _batch_vector_input_param_values;
362 if (_use_decomposed_index)
363 {
364 processed_batch_indices.push_back(std::vector<unsigned int>(
365 processed_batch_vector_input_param_values.empty()
366 ? processed_batch_scalar_input_param_values.front().size()
367 : processed_batch_vector_input_param_values.front().size()));
368 std::iota(processed_batch_indices.back().begin(), processed_batch_indices.back().end(), 0);
369 }
370 }
371 else // cartesian_product
372 {
373 // We basically need to reconstruct the corresponding parameters based on the cartesian product
374 // algorithm
375 for (const auto i : index_range(_batch_scalar_input_param_values))
376 {
377 // For the first element, just copy the parameters
378 if (processed_batch_scalar_input_param_values.empty())
379 {
380 processed_batch_scalar_input_param_values.push_back(_batch_scalar_input_param_values[i]);
381 if (_use_decomposed_index)
382 {
383 processed_batch_indices.push_back(
384 std::vector<unsigned int>(_batch_scalar_input_param_values[i].size()));
385 std::iota(
386 processed_batch_indices.back().begin(), processed_batch_indices.back().end(), 0);
387 }
388 }
389 else
390 {
391 const unsigned int num_new_batch_params = _batch_scalar_input_param_values[i].size();
392 const unsigned int num_processed_batch_params =
393 processed_batch_scalar_input_param_values.front().size();
394 // All the elements in the processed_batch_scalar_input_param_values need to be duplicated
395 // for num_new_batch_params times
396 for (auto & unit_processed_batch_scalar_input_param_values :
397 processed_batch_scalar_input_param_values)
398 {
399 auto temp_params = unit_processed_batch_scalar_input_param_values;
400 for (unsigned int j = 1; j < num_new_batch_params; j++)
401 {
402 unit_processed_batch_scalar_input_param_values.insert(
403 unit_processed_batch_scalar_input_param_values.end(),
404 temp_params.begin(),
405 temp_params.end());
406 }
407 }
408 if (_use_decomposed_index)
409 {
410 // Same as the composed indices
411 for (auto & unit_processed_batch_indices : processed_batch_indices)
412 {
413 auto temp_indices = unit_processed_batch_indices;
414 for (unsigned int j = 1; j < num_new_batch_params; j++)
415 {
416 unit_processed_batch_indices.insert(
417 unit_processed_batch_indices.end(), temp_indices.begin(), temp_indices.end());
418 }
419 }
420 }
421
422 // Then, add a new element to the processed_batch_scalar_input_param_values by repeating
423 // each element in _batch_scalar_input_param_values[i] for num_processed_batch_params times
424 processed_batch_scalar_input_param_values.push_back({});
425 for (const auto & unit_batch_scalar_input_param_values :
426 _batch_scalar_input_param_values[i])
427 for (unsigned int j = 0; j < num_processed_batch_params; j++)
428 processed_batch_scalar_input_param_values.back().push_back(
429 unit_batch_scalar_input_param_values);
430 if (_use_decomposed_index)
431 {
432 // Same as the composed indices
433 processed_batch_indices.push_back({});
434 for (const auto & unit_batch_scalar_input_param_values_index :
435 index_range(_batch_scalar_input_param_values[i]))
436 for (unsigned int j = 0; j < num_processed_batch_params; j++)
437 processed_batch_indices.back().push_back(unit_batch_scalar_input_param_values_index);
438 }
439 }
440 }
441 for (const auto i : index_range(_batch_vector_input_param_values))
442 {
443 // For the first element, just copy the parameters
444 if (processed_batch_vector_input_param_values.empty())
445 {
446 if (processed_batch_scalar_input_param_values.empty())
447 {
448 // if no batch scalar input parameters are used
449 // we just need to initiate the processed_batch_vector_input_param_values as the first one
450 // to fill
451 processed_batch_vector_input_param_values.push_back(_batch_vector_input_param_values[i]);
452 if (_use_decomposed_index)
453 {
454 processed_batch_indices.push_back(
455 std::vector<unsigned int>(_batch_vector_input_param_values[i].size()));
456 std::iota(
457 processed_batch_indices.back().begin(), processed_batch_indices.back().end(), 0);
458 }
459 }
460 else
461 {
462 processed_batch_vector_input_param_values.push_back({});
463 // if there are batch scalar input parameters, then each element needs to be duplicated
464 // for that amount of times
465 for (const auto & unit_batch_vector_input_param_values :
466 _batch_vector_input_param_values[i])
467 for (unsigned int j = 0; j < processed_batch_scalar_input_param_values.front().size();
468 j++)
469 processed_batch_vector_input_param_values.back().push_back(
470 unit_batch_vector_input_param_values);
471 // Then the scalar input parameters need to be duplicated for the number of elements in
472 // the processed_batch_vector_input_param_values
473 for (auto & unit_processed_batch_scalar_input_param_values :
474 processed_batch_scalar_input_param_values)
475 {
476 auto temp_params = unit_processed_batch_scalar_input_param_values;
477 for (unsigned int j = 1; j < processed_batch_vector_input_param_values.back().size();
478 j++)
479 {
480 unit_processed_batch_scalar_input_param_values.insert(
481 unit_processed_batch_scalar_input_param_values.end(),
482 temp_params.begin(),
483 temp_params.end());
484 }
485 }
486 if (_use_decomposed_index)
487 {
488 // Add the indices for the first batch vector input parameter
489 processed_batch_indices.push_back({});
490 for (const auto & unit_batch_vector_input_param_values_index :
491 index_range(_batch_vector_input_param_values[i]))
492 for (unsigned int j = 0; j < processed_batch_indices.front().size(); j++)
493 processed_batch_indices.back().push_back(
494 unit_batch_vector_input_param_values_index);
495 // Duplicate the indices for the batch scalar input parameters
496 for (unsigned int k = 1; k < processed_batch_indices.size(); k++)
497 {
498 auto & unit_processed_batch_indices = processed_batch_indices[k - 1];
499 auto temp_indices = unit_processed_batch_indices;
500 for (unsigned int j = 1; j < _batch_vector_input_param_values[i].size(); j++)
501 {
502 unit_processed_batch_indices.insert(
503 unit_processed_batch_indices.end(), temp_indices.begin(), temp_indices.end());
504 }
505 }
506 }
507 }
508 }
509 else
510 {
511 const unsigned int num_new_batch_params = _batch_vector_input_param_values[i].size();
512 const unsigned int num_processed_batch_params =
513 processed_batch_vector_input_param_values.front().size();
514 // All the elements in the processed_batch_vector_input_param_values need to be duplicated
515 // for num_new_batch_params times
516 for (auto & unit_processed_batch_vector_input_param_values :
517 processed_batch_vector_input_param_values)
518 {
519 auto temp_params = unit_processed_batch_vector_input_param_values;
520 for (unsigned int j = 1; j < num_new_batch_params; j++)
521 {
522 unit_processed_batch_vector_input_param_values.insert(
523 unit_processed_batch_vector_input_param_values.end(),
524 temp_params.begin(),
525 temp_params.end());
526 }
527 }
528 if (_use_decomposed_index)
529 {
530 // Same for the decomposed indices
531 for (auto & unit_processed_batch_indices : processed_batch_indices)
532 {
533 auto temp_indices = unit_processed_batch_indices;
534 for (unsigned int j = 1; j < num_new_batch_params; j++)
535 {
536 unit_processed_batch_indices.insert(
537 unit_processed_batch_indices.end(), temp_indices.begin(), temp_indices.end());
538 }
539 }
540 }
541 // if there are also batch scalar input parameters, it also needs to be duplicated
542 for (auto & unit_processed_batch_scalar_input_param_values :
543 processed_batch_scalar_input_param_values)
544 {
545 auto temp_params = unit_processed_batch_scalar_input_param_values;
546 for (unsigned int j = 1; j < num_new_batch_params; j++)
547 {
548 unit_processed_batch_scalar_input_param_values.insert(
549 unit_processed_batch_scalar_input_param_values.end(),
550 temp_params.begin(),
551 temp_params.end());
552 }
553 }
554 // Then, add a new element to the processed_batch_vector_input_param_values by repeating
555 // each element in _batch_vector_input_param_values[i] for num_processed_batch_params times
556 processed_batch_vector_input_param_values.push_back({});
557 for (const auto & unit_batch_vector_input_param_values :
558 _batch_vector_input_param_values[i])
559 for (unsigned int j = 0; j < num_processed_batch_params; j++)
560 processed_batch_vector_input_param_values.back().push_back(
561 unit_batch_vector_input_param_values);
562 if (_use_decomposed_index)
563 {
564 // Same for the decomposed indices
565 processed_batch_indices.push_back({});
566 for (const auto & unit_batch_vector_input_param_values_index :
567 index_range(_batch_vector_input_param_values[i]))
568 for (unsigned int j = 0; j < num_processed_batch_params; j++)
569 processed_batch_indices.back().push_back(unit_batch_vector_input_param_values_index);
570 }
571 }
572 }
573 }
574
575 // Now, we can add the mesh generators by looping through the processed params
576 const unsigned int num_batch_params =
577 processed_batch_vector_input_param_values.empty()
578 ? processed_batch_scalar_input_param_values.front().size()
579 : processed_batch_vector_input_param_values.front().size();
580 for (const auto i : make_range(num_batch_params))
581 {
582 auto params = _app.getFactory().getValidParams(_mesh_generator_type);
583 for (const auto j : index_range(_batch_scalar_input_param_values))
584 setScalarParams(params,
585 _batch_scalar_input_param_names[j],
586 _batch_scalar_input_param_types[j],
587 processed_batch_scalar_input_param_values[j][i]);
588 for (const auto j : index_range(_batch_vector_input_param_values))
589 setVectorParams(params,
590 _batch_vector_input_param_names[j],
591 _batch_vector_input_param_types[j],
592 processed_batch_vector_input_param_values[j][i]);
593 for (const auto j : index_range(_fixed_scalar_input_param_names))
594 setScalarParams(params,
595 _fixed_scalar_input_param_names[j],
596 _fixed_scalar_input_param_types[j],
597 _fixed_scalar_input_param_values[j]);
598 for (const auto j : index_range(_fixed_vector_input_param_names))
599 setVectorParams(params,
600 _fixed_vector_input_param_names[j],
601 _fixed_vector_input_param_types[j],
602 _fixed_vector_input_param_values[j]);
603
604 std::string mesh_index;
605 if (_use_decomposed_index)
606 for (const auto & process_batch_index : processed_batch_indices)
607 mesh_index += '_' + std::to_string(process_batch_index[i]);
608 else
609 mesh_index = "_" + std::to_string(i);
610
611 _app.getMeshGeneratorSystem().addMeshGenerator(
612 _mesh_generator_type, _mesh_name_prefix + mesh_index, params);
613 }
614}
for
for(PetscInt i=0;i< nvars;++i)
Definition PetscDMMoose.C:1721
int
void ErrorVector unsigned int
BatchMeshGeneratorAction::setVectorParams
void setVectorParams(InputParameters &params, const std::string &param_name, const ParameterType &param_type, const std::vector< std::string > &param_value) const
Set the vector input parameters for a unit mesh generator.
Definition BatchMeshGeneratorAction.C:697
BatchMeshGeneratorAction::setScalarParams
void setScalarParams(InputParameters &params, const std::string &param_name, const ParameterType &param_type, const std::string &param_value) const
Set the scalar input parameters for a unit mesh generator.
Definition BatchMeshGeneratorAction.C:617
MeshGeneratorSystem::addMeshGenerator
void addMeshGenerator(const std::string &type, const std::string &name, const InputParameters &params)
Add a mesh generator that will act on the meshes in the system.
Definition MeshGeneratorSystem.C:34
MooseApp::getMeshGeneratorSystem
MeshGeneratorSystem & getMeshGeneratorSystem()
Gets the system that manages the MeshGenerators.
Definition MooseApp.h:886
libMesh::make_range
IntRange< T > make_range(T beg, T end)

Referenced by act().

◆ addRelationshipManager()

bool Action::addRelationshipManager ( Moose::RelationshipManagerType  input_rm_type,
const InputParameters &  moose_object_pars,
std::string  rm_name,
Moose::RelationshipManagerType  rm_type,
Moose::RelationshipManagerInputParameterCallback  rm_input_parameter_func,
Moose::RMSystemType  sys_type = Moose::RMSystemType::NONE 
)
privateinherited

Method for adding a single relationship manager.

Parameters
input_rm_typeWhat relationship manager type we are currently adding
moose_object_parsThe parameters of the MooseObject that requested the RM
rm_nameThe class type of the RM, e.g. ElementSideNeighborLayers
rm_typeThe RelationshipManagerType, e.g. geometric, algebraic, coupling
rm_input_parameter_funcThe RM callback function, typically a lambda defined in the requesting MooseObject's validParams function
sys_typeA RMSystemType that can be used to limit the systems and consequent dof_maps that the RM can be attached to
Returns
Whether a relationship manager was added

Definition at line 100 of file Action.C.

107{
108 // These need unique names
109 static unsigned int unique_object_id = 0;
110
111 auto new_name = moose_object_pars.getBase() + '_' + name() + '_' + rm_name + "_" +
112 Moose::stringify(rm_type) + " " + std::to_string(unique_object_id);
113
114 auto rm_params = _factory.getValidParams(rm_name);
115 rm_params.set<Moose::RelationshipManagerType>("rm_type") = rm_type;
116
117 rm_params.set<std::string>("for_whom") = name();
118
119 // If there is a callback for setting the RM parameters let's use it
120 if (rm_input_parameter_func)
121 rm_input_parameter_func(moose_object_pars, rm_params);
122
123 rm_params.set<MooseMesh *>("mesh") = _mesh.get();
124
125 if (!rm_params.areAllRequiredParamsValid())
126 mooseError("Missing required parameters for RelationshipManager " + rm_name + " for object " +
127 name());
128
129 auto rm_obj = _factory.create<RelationshipManager>(rm_name, new_name, rm_params);
130
131 const bool added = _app.addRelationshipManager(rm_obj);
132
133 // Delete the resources created on behalf of the RM if it ends up not being added to the App.
134 if (!added)
135 _factory.releaseSharedObjects(*rm_obj);
136 else // we added it
137 unique_object_id++;
138
139 return added;
140}
Action::_mesh
std::shared_ptr< MooseMesh > & _mesh
Definition Action.h:174
Factory::create
std::shared_ptr< MooseObject > create(const std::string &obj_name, const std::string &name, const InputParameters &parameters, THREAD_ID tid=0, bool print_deprecated=true)
Definition Factory.C:142
Factory::releaseSharedObjects
void releaseSharedObjects(const MooseObject &moose_object, THREAD_ID tid=0)
Releases any shared resources created as a side effect of creating an object through the Factory::cre...
Definition Factory.C:156
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition InputParameters.h:1596
InputParameters::getBase
const std::string & getBase() const
Definition InputParameters.C:505
MooseApp::addRelationshipManager
bool addRelationshipManager(std::shared_ptr< RelationshipManager > relationship_manager)
Transfers ownership of a RelationshipManager to the application for lifetime management.
Definition MooseApp.C:2991
MooseBase::name
const std::string & name() const
Get the name of the class.
Definition MooseBase.h:103
MooseMesh
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition MooseMesh.h:95
ParallelParamObject::_factory
Factory & _factory
The Factory associated with the MooseApp.
Definition ParallelParamObject.h:37
RelationshipManager
RelationshipManagers are used for describing what kinds of non-local resources are needed for an obje...
Definition RelationshipManager.h:27
Moose::stringify
std::string stringify(const T &t)
conversion to string
Definition Conversion.h:64
Moose::RelationshipManagerType
RelationshipManagerType
Main types of Relationship Managers.
Definition MooseTypes.h:1018

Referenced by Action::addRelationshipManagers().

◆ addRelationshipManagers() [1/2]

void Action::addRelationshipManagers ( Moose::RelationshipManagerType  when_type)
virtualinherited

Method to add a relationship manager for the objects being added to the system.

Relationship managers have to be added relatively early. In many cases before the Action::act() method is called.

Parameters
when_typeThe parameter indicating the normal time for adding either Geometric or Algebraic RelationshipManagers. It may not always be possible to add your RelationshipManager as early as you'd like. In these cases, your DistributedMesh may consume more memory during the problem setup.

Reimplemented in ProjectedStatefulMaterialStorageAction, PhysicsBase, AddActionComponentAction, MooseObjectAction, ProjectedStatefulMaterialStorageAction, PhysicsBase, AddActionComponentAction, and MooseObjectAction.

Definition at line 143 of file Action.C.

144{
145}

◆ addRelationshipManagers() [2/2]

bool Action::addRelationshipManagers ( Moose::RelationshipManagerType  when_type,
const InputParameters &  moose_object_pars 
)
protectedinherited

Method to add a relationship manager for the objects being added to the system.

Relationship managers have to be added relatively early. In many cases before the Action::act() method is called.

Parameters
when_typeThe parameter indicating the normal time for adding either Geometric or Algebraic RelationshipManagers. It may not always be possible to add your RelationshipManager as early as you'd like. In these cases, your DistributedMesh may consume more memory during the problem setup.
moose_object_parsThe MooseObject to inspect for RelationshipManagers to add
Returns
Whether a relationship manager was added

Definition at line 148 of file Action.C.

150{
151 const auto & buildable_types = moose_object_pars.getBuildableRelationshipManagerTypes();
152
153 bool added = false;
154
155 for (const auto & buildable_type : buildable_types)
156 {
157 auto & rm_name = std::get<0>(buildable_type);
158 auto & rm_type = std::get<1>(buildable_type);
159 auto rm_input_parameter_func = std::get<2>(buildable_type);
160
161 added = addRelationshipManager(
162 input_rm_type, moose_object_pars, rm_name, rm_type, rm_input_parameter_func) ||
163 added;
164 }
165
166 return added;
167}
Action::addRelationshipManager
bool addRelationshipManager(Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)
Method for adding a single relationship manager.
Definition Action.C:100
InputParameters::getBuildableRelationshipManagerTypes
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.
Definition InputParameters.C:554

Referenced by CouplingFunctorCheckAction::act(), and PhysicsBase::addRelationshipManagers().

◆ appendTask()

void Action::appendTask ( const std::string &  task)
inlineinherited

Definition at line 114 of file Action.h.

114{ _all_tasks.insert(task); }
Action::_all_tasks
std::set< std::string > _all_tasks
A list of all the tasks that this Action will satisfy.
Definition Action.h:166

◆ assertParamDefined() [1/2]

void InputParametersChecksUtils< BatchMeshGeneratorAction >::assertParamDefined ( const std::string &  libmesh_dbg_varparam) const
inherited

Definition at line 206 of file InputParametersChecksUtils.h.

207{
208 mooseAssert(forwardParameters().template have_parameter<T>(param),
209 "Parameter '" + param + "' is not defined with type '" +
210 MooseUtils::prettyCppType<T>() + "' in object type '" +
211 MooseUtils::prettyCppType(forwardType()) + "'. Check your code.");
212}
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardParameters
const InputParameters & forwardParameters() const
Forwards obtaining parameters to the class using this utility.
Definition InputParametersChecksUtils.h:158
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardType
const std::string & forwardType() const
Get the type of the class using this utility.
Definition InputParametersChecksUtils.h:188
MooseUtils::prettyCppType
std::string prettyCppType(const std::string &cpp_type)
Definition MooseUtils.C:1151

◆ assertParamDefined() [2/2]

void InputParametersChecksUtils< BatchMeshGeneratorAction >::assertParamDefined ( const std::string &  param) const
protectedinherited

Check in debug mode that this parameter has been added to the validParams.

Parameters
paramparameter that should be defined

◆ associateWithParameter() [1/2]

void Action::associateWithParameter ( const InputParameters &  from_params,
const std::string &  param_name,
InputParameters &  params 
) const
protectedinherited

The same as associateWithParameter() without from_params, but instead allows you to associate this with another object's parameters instead of the parameters from this action.

An example here is when you want to associate the creation of an action with an argument from the application.

Definition at line 176 of file Action.C.

179{
180 const auto to_hit_node = params.getHitNode();
181 if (!to_hit_node || to_hit_node->isRoot())
182 {
183 if (const auto hit_node = from_params.getHitNode(param_name))
184 params.setHitNode(*hit_node, {});
185 else if (const auto hit_node = from_params.getHitNode())
186 params.setHitNode(*hit_node, {});
187 }
188}
InputParameters::setHitNode
void setHitNode(const std::string &param, const hit::Node &node, const SetParamHitNodeKey)
Sets the hit node associated with the parameter param to node.
Definition InputParameters.C:1633
InputParameters::getHitNode
const hit::Node * getHitNode(const std::string &param) const
Definition InputParameters.C:1627

◆ associateWithParameter() [2/2]

void Action::associateWithParameter ( const std::string &  param_name,
InputParameters &  params 
) const
protectedinherited

Associates the object's parameters params with the input location from this Action's parameter with the name param_name, if one exists.

For example, you have a parameter in this action of type bool with name "add_mesh". You then add an action within this action that creates a mesh if this param is true. If you call associateWithParameter("add_mesh", action_params) where action_params are the parameters for the action, we then associate that action with the "add_mesh" parameter. Therefore, the resulting created mesh will also be associated with the "add_mesh" param and any errors that are non-parameter errors (i.e., mooseError/mooseWarning) will have the line context of the "add_mesh" parameter in this action. The same goes for any errors that are produce within the created action.

Definition at line 170 of file Action.C.

171{
172 associateWithParameter(parameters(), param_name, params);
173}
Action::associateWithParameter
void associateWithParameter(const std::string &param_name, InputParameters &params) const
Associates the object's parameters params with the input location from this Action's parameter with t...
Definition Action.C:170
MooseBase::parameters
const InputParameters & parameters() const
Get the parameters of the object.
Definition MooseBase.h:131

Referenced by Action::associateWithParameter(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ callMooseError() [1/2]

void MooseBase::callMooseError ( MooseApp *const  app,
const InputParameters &  params,
std::string  msg,
const bool  with_prefix,
const hit::Node *  node,
const bool  show_trace = true 
)
staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters
appThe app pointer (if available); adds multiapp context and clears the console
paramsThe parameters, needed to obtain object information
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix
show_traceWhether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

120{
121 if (!node)
122 node = MooseBase::getHitNode(params);
123
124 std::string multiapp_prefix = "";
125 if (app)
126 {
127 if (!app->isUltimateMaster())
128 multiapp_prefix = app->name();
129 app->getOutputWarehouse().mooseConsole();
130 }
131
132 if (with_prefix)
133 // False here because the hit context will get processed by the node
134 msg = messagePrefix(params, false) + msg;
135
136 moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
137}
MooseApp::getOutputWarehouse
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition MooseApp.C:2409
MooseApp::isUltimateMaster
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition MooseApp.h:866
MooseBase::getHitNode
const hit::Node * getHitNode() const
Definition MooseBase.h:136
MooseBase::messagePrefix
std::string messagePrefix(const bool hit_prefix=true) const
Definition MooseBase.h:256
OutputWarehouse::mooseConsole
void mooseConsole()
Send current output buffer to Console output objects.
Definition OutputWarehouse.C:199
moose::internal::mooseErrorRaw
void mooseErrorRaw(std::string msg, const std::string &prefix="", const hit::Node *node=nullptr, const bool show_trace=true)
Main callback for emitting a moose error.
Definition MooseError.C:53

◆ callMooseError() [2/2]

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

External method for calling moose error with added object context.

Parameters
msgThe message
with_prefixIf true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
nodeOptional hit node to add file path context as a prefix
show_traceWhether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

109{
110 callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
111}
MooseBase::_app
MooseApp & _app
The MOOSE application this is associated with.
Definition MooseBase.h:375
MooseBase::callMooseError
void callMooseError(std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
External method for calling moose error with added object context.
Definition MooseBase.C:105
MooseBase::_pars
const InputParameters & _pars
The object's parameters.
Definition MooseBase.h:384

Referenced by MooseBase::callMooseError(), InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

◆ checkBlockwiseConsistency()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkBlockwiseConsistency ( const std::string &  block_param_name,
const std::vector< std::string > &  parameter_names 
) const
protectedinherited

Check if the user commited errors during the definition of block-wise parameters.

Parameters
block_param_namethe name of the parameter that provides the groups of blocks
parameter_namesvector of the names of the parameters that are defined on a per-block basis

Definition at line 120 of file InputParametersChecksUtils.h.

485{
486 const std::vector<std::vector<SubdomainName>> & block_names =
487 forwardGetParam<std::vector<std::vector<SubdomainName>>>(block_param_name);
488
489 if (block_names.size())
490 {
491 // We only check block-restrictions if the customer class is not restricted to `ANY_BLOCK_ID`.
492 // If the users define blocks that are not on the mesh, they will receive errors from the
493 // objects created by the customer class
494 const auto & object_blocks = forwardBlocks();
495 if (std::find(object_blocks.begin(), object_blocks.end(), "ANY_BLOCK_ID") ==
496 object_blocks.end())
497 for (const auto & block_group : block_names)
498 for (const auto & block : block_group)
499 if (std::find(object_blocks.begin(), object_blocks.end(), block) == object_blocks.end())
500 forwardParamError(block_param_name,
501 "Block '" + block + "' is not present in the block restriction of " +
502 forwardName() +
503 "!\nBlock restriction: " + Moose::stringify(object_blocks));
504
505 for (const auto & param_name : parameter_names)
506 {
507 const std::vector<T> & param_vector = forwardGetParam<std::vector<T>>(param_name);
508 if (block_names.size() != param_vector.size())
509 forwardParamError(param_name,
510 "The number of entries in '" + param_name + "' (" +
511 std::to_string(param_vector.size()) +
512 ") is not the same as the number of blocks"
513 " (" +
514 std::to_string(block_names.size()) + ") in '" + block_param_name +
515 "'!");
516 }
517 }
518 else
519 {
520 unsigned int previous_size = 0;
521 for (const auto param_i : index_range(parameter_names))
522 {
523 const std::vector<T> & param_vector =
524 forwardGetParam<std::vector<T>>(parameter_names[param_i]);
525 if (param_i == 0)
526 {
527 if (param_vector.size() > 1)
528 forwardParamError(parameter_names[param_i],
529 "The user should only use one or zero entries in " +
530 parameter_names[param_i] + " if " + block_param_name +
531 " not defined!");
532 previous_size = param_vector.size();
533 }
534 else
535 {
536 if (previous_size != param_vector.size())
537 forwardParamError(parameter_names[param_i],
538 "The number of entries in '" + parameter_names[param_i] +
539 "' is not the same as the number of entries in '" +
540 parameter_names[param_i - 1] + "'!");
541 }
542 }
543 }
544}
if
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardParamError
void forwardParamError(Args &&... args) const
Forwards error to the class using this utility to get better error messages.
Definition InputParametersChecksUtils.h:171
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardBlocks
const std::vector< SubdomainName > & forwardBlocks() const
Get the blocks for the class using this utility.
Definition InputParametersChecksUtils.h:192
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardName
virtual const std::string & forwardName() const
Get the name of the class using this utility.
Definition InputParametersChecksUtils.h:190
Moose::Kokkos::Utils::find
KOKKOS_INLINE_FUNCTION const T * find(const T &target, const T *const begin, const T *const end)
Find a value in an array.
Definition KokkosUtils.h:40
NEML2Utils::stringify
std::string stringify(MOOSEIOType type)
Definition NEML2Utils.C:18

◆ checkInputParametersTypes()

void BatchMeshGeneratorAction::checkInputParametersTypes ( const InputParameters &  params,
const std::string &  action_input_param_name,
const std::vector< std::string > &  param_names,
const std::vector< ParameterType > &  param_types,
const bool &  is_vector = false 
) const
protected

Check the types of the input parameters are valid, otherwise throw an error.

Parameters
paramsInputParameters object to check the parameters
action_input_param_nameName of the action input parameter used for error message
param_namesNames of the parameters to check
param_typesTypes of the parameters to check
is_vectorFlag to indicate if the parameters are vectors

Definition at line 832 of file BatchMeshGeneratorAction.C.

837{
838 for (const auto i : index_range(param_names))
839 {
840 switch (param_types[i])
841 {
842 case (ParameterType::REAL):
843 checkInputParameterType<Real>(params, action_input_param_name, param_names[i], is_vector);
844 break;
845 case (ParameterType::SHORT):
846 checkInputParameterType<short>(params, action_input_param_name, param_names[i], is_vector);
847 break;
848 case (ParameterType::USHORT):
849 checkInputParameterType<unsigned short>(
850 params, action_input_param_name, param_names[i], is_vector);
851 break;
852 case (ParameterType::INT):
853 checkInputParameterType<int>(params, action_input_param_name, param_names[i], is_vector);
854 break;
855 case (ParameterType::UINT):
856 checkInputParameterType<unsigned int>(
857 params, action_input_param_name, param_names[i], is_vector);
858 break;
859 case (ParameterType::LONG):
860 checkInputParameterType<long>(params, action_input_param_name, param_names[i], is_vector);
861 break;
862 case (ParameterType::ULONG):
863 checkInputParameterType<unsigned long>(
864 params, action_input_param_name, param_names[i], is_vector);
865 break;
866 case (ParameterType::LONGLONG):
867 checkInputParameterType<long long>(
868 params, action_input_param_name, param_names[i], is_vector);
869 break;
870 case (ParameterType::ULONGLONG):
871 checkInputParameterType<unsigned long long>(
872 params, action_input_param_name, param_names[i], is_vector);
873 break;
874 case (ParameterType::DOFIDTYPE):
875 checkInputParameterType<dof_id_type>(
876 params, action_input_param_name, param_names[i], is_vector);
877 break;
878 case (ParameterType::BDRYIDTYPE):
879 checkInputParameterType<boundary_id_type>(
880 params, action_input_param_name, param_names[i], is_vector);
881 break;
882 case (ParameterType::SDIDTYPE):
883 checkInputParameterType<subdomain_id_type>(
884 params, action_input_param_name, param_names[i], is_vector);
885 break;
886 case (ParameterType::ENUM):
887 if (is_vector)
888 checkInputParameterType<MultiMooseEnum>(
889 params, action_input_param_name, param_names[i], false);
890 else
891 checkInputParameterType<MooseEnum>(
892 params, action_input_param_name, param_names[i], false);
893 break;
894 case (ParameterType::STRING):
895 checkInputParameterType<std::string>(
896 params, action_input_param_name, param_names[i], is_vector);
897 break;
898 case (ParameterType::SDNAME):
899 checkInputParameterType<SubdomainName>(
900 params, action_input_param_name, param_names[i], is_vector);
901 break;
902 case (ParameterType::BDRYNAME):
903 checkInputParameterType<BoundaryName>(
904 params, action_input_param_name, param_names[i], is_vector);
905 break;
906 case (ParameterType::MGNAME):
907 checkInputParameterType<MeshGeneratorName>(
908 params, action_input_param_name, param_names[i], is_vector);
909 break;
910 case (ParameterType::MFNAME):
911 checkInputParameterType<MeshFileName>(
912 params, action_input_param_name, param_names[i], is_vector);
913 break;
914 case (ParameterType::BOOL):
915 checkInputParameterType<bool>(params, action_input_param_name, param_names[i], is_vector);
916 break;
917 case (ParameterType::REALVECTORVALUE):
918 checkInputParameterType<RealVectorValue>(
919 params, action_input_param_name, param_names[i], is_vector);
920 break;
921 case (ParameterType::POINT):
922 checkInputParameterType<Point>(params, action_input_param_name, param_names[i], is_vector);
923 break;
924 default:
925 mooseAssert(
926 false,
927 "impossible situation."); // as we use MultiMooseEnum to ensure the type is valid
928 }
929 }
930}

Referenced by BatchMeshGeneratorAction().

◆ checkInputParameterType()

template<typename T >
void BatchMeshGeneratorAction::checkInputParameterType ( const InputParameters &  params,
const std::string &  action_input_param_name,
const std::string &  param_name,
const bool &  is_vector 
) const
protected

Check the type of the input parameter is valid, otherwise throw an error.

Parameters
paramsInputParameters object to check the parameter
action_input_param_nameName of the action input parameter used for error message
param_nameName of the parameter to check
is_vectorFlag to indicate if the parameter is a vector

Definition at line 934 of file BatchMeshGeneratorAction.C.

938{
939 if ((is_vector && !params.isType<std::vector<T>>(param_name)) ||
940 (!is_vector && !params.isType<T>(param_name)))
941 paramError(action_input_param_name,
942 "the input parameter, " + param_name + ", has the wrong type. It should be " +
943 params.type(param_name) + ".");
944}
InputParameters::type
std::string type(const std::string &name) const
Prints the type of the requested parameter by name.
Definition InputParameters.C:916
InputParameters::isType
bool isType(const std::string &name) const
Definition InputParameters.h:2381

◆ checkParamsBothSetOrNotSet()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkParamsBothSetOrNotSet ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that two parameters are either both set or both not set.

Parameters
param1first parameter to check
param2second parameter to check

Definition at line 40 of file InputParametersChecksUtils.h.

594{
595 if ((forwardIsParamValid(param1) + forwardIsParamValid(param2)) % 2 != 0)
596 forwardParamError(param1,
597 "Parameters '" + param1 + "' and '" + param2 +
598 "' must be either both set or both not set.");
599}
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardIsParamValid
bool forwardIsParamValid(const std::string &param_name) const
Forwards parameter check to the class using this utility.
Definition InputParametersChecksUtils.h:165

◆ checkSecondParamNotSetIfFirstOneSet()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkSecondParamNotSetIfFirstOneSet ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that a parameter is not set if the first one is set.

Parameters
param1first parameter to check, check that the second is not if this one is set
param2second parameter to check, that should not be set if first one is set

Definition at line 54 of file InputParametersChecksUtils.h.

630{
631 if (forwardIsParamSetByUser(param1) && forwardIsParamSetByUser(param2))
632 forwardParamError(param2,
633 "Parameter '" + param2 + "' should not be specified if parameter '" + param1 +
634 "' is specified.");
635}
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardIsParamSetByUser
bool forwardIsParamSetByUser(const std::string &param_name) const
Forwards parameter check to the class using this utility.
Definition InputParametersChecksUtils.h:160

◆ checkSecondParamSetOnlyIfFirstOneSet()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkSecondParamSetOnlyIfFirstOneSet ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that a parameter is set only if the first one is set.

Parameters
param1first parameter to check, check the second if set
param2second parameter to check, that should be set if first one is set

Definition at line 49 of file InputParametersChecksUtils.h.

619{
620 if (!forwardIsParamSetByUser(param1) && forwardIsParamSetByUser(param2))
621 forwardParamError(param2,
622 "Parameter '" + param2 + "' should not be set if parameter '" + param1 +
623 "' is not specified.");
624}

◆ checkSecondParamSetOnlyIfFirstOneTrue()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkSecondParamSetOnlyIfFirstOneTrue ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that a parameter is set only if the first one is set to true.

Parameters
param1first parameter to check, check the second if true
param2second parameter to check, that should be set if first one is true

Definition at line 44 of file InputParametersChecksUtils.h.

605{
606 mooseAssert(forwardParameters().template have_parameter<bool>(param1),
607 "Cannot check if parameter " + param1 +
608 " is true if it's not a bool parameter of this object");
609 if (!forwardGetParam<bool>(param1) && forwardIsParamSetByUser(param2))
610 forwardParamError(param2,
611 "Parameter '" + param1 + "' cannot be set to false if parameter '" + param2 +
612 "' is set by the user");
613}

◆ checkTwoDVectorParamInnerSameLengthAsOneDVector()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkTwoDVectorParamInnerSameLengthAsOneDVector ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that each inner vector of a two-D vector parameter are the same size as another one-D vector parameter.

Parameters
param1two-D vector parameter to check the dimensions of
param2one-D vector parameter to set the desired size

Definition at line 87 of file InputParametersChecksUtils.h.

298{
299 assertParamDefined<std::vector<std::vector<T>>>(param1);
300 assertParamDefined<std::vector<S>>(param2);
301 for (const auto & sub_vec_i : index_range(forwardGetParam<std::vector<std::vector<T>>>(param1)))
302 {
303 const auto size_1 = forwardGetParam<std::vector<std::vector<T>>>(param1)[sub_vec_i].size();
304 const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
305 if (size_1 != size_2)
306 forwardParamError(param1,
307 "Vector at index " + std::to_string(sub_vec_i) + " (size " +
308 std::to_string(size_1) +
309 ") "
310 " of this parameter should be the same length as parameter '" +
311 param2 + "' (size " + std::to_string(size_2) + ")");
312 }
313}
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardGetParam
const T & forwardGetParam(const std::string &param_name) const
Forwards parameter check to the class using this utility.
Definition InputParametersChecksUtils.h:153

◆ checkTwoDVectorParamMultiMooseEnumSameLength()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkTwoDVectorParamMultiMooseEnumSameLength ( const std::string &  param1,
const std::string &  param2,
const bool  error_for_param2 
) const
protectedinherited

Check that the size of a two-D vector parameter matches the size of a MultiMooseEnum parameter.

Parameters
param1two-D vector parameter to check the unrolled size of
param2MultiMooseEnum parameter to set the desired size

Definition at line 93 of file InputParametersChecksUtils.h.

320{
321 assertParamDefined<std::vector<std::vector<T>>>(param1);
322 assertParamDefined<MultiMooseEnum>(param2);
323 const auto vec1 = forwardGetParam<std::vector<std::vector<T>>>(param1);
324 const auto enum2 = forwardGetParam<MultiMooseEnum>(param2);
325 const auto size_1 = vec1.empty() ? 0 : vec1.size() * vec1[0].size();
326 const auto size_2 = enum2.size();
327 if (size_1 != size_2)
328 {
329 if (error_for_param2)
330 forwardParamError(param2,
331 "Vector enumeration parameter (size " + std::to_string(size_2) +
332 ") is not the same size as the vector of vector parameter '" + param1 +
333 "' (size " + std::to_string(size_1) + ")");
334 else
335 forwardParamError(param1,
336 "Vector of vector parameter '" + param1 + "' (total size " +
337 std::to_string(size_1) +
338 ") is not the same size as vector-enumeration parameter '" + param2 +
339 "' (size " + std::to_string(size_2) + ")");
340 }
341}

◆ checkTwoDVectorParamsNoRespectiveOverlap()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkTwoDVectorParamsNoRespectiveOverlap ( const std::vector< std::string > &  param_vecs) const
protectedinherited

Check that there is no overlap between the respective items in each vector of the two-D parameters Each vector of the two-D vector parameter should also have unique items.

Parameters
param_vecsvector of parameters that should not overlap with each other

Definition at line 82 of file InputParametersChecksUtils.h.

397{
398 // Outer loop, each param is the name of a parameter for a vector of vectors
399 for (const auto & param : param_vec)
400 {
401 assertParamDefined<std::vector<std::vector<T>>>(param);
402 const auto & twoD_vec = forwardGetParam<std::vector<std::vector<T>>>(param);
403 std::vector<std::set<T>> unique_params(twoD_vec.size());
404
405 // Loop over each outer vector and compare the inner vectors respectively to other parameters
406 for (const auto i : index_range(twoD_vec))
407 {
408 for (const auto & value : twoD_vec[i])
409 if (!unique_params[i].insert(value).second)
410 {
411 auto copy_params = param_vec;
412 copy_params.erase(std::find(copy_params.begin(), copy_params.end(), param));
413 forwardMooseError("Item '" + value + "' specified in vector parameter '" + param +
414 "' is also present in one or more of the two-D vector parameters '" +
415 Moose::stringify(copy_params) +
416 "' in the inner vector of the same index, which is not allowed.");
417 }
418 }
419 }
420}
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardMooseError
void forwardMooseError(Args &&... args) const
Forwards error to the class using this utility to get better error messages.
Definition InputParametersChecksUtils.h:177
libMesh::JacobiPolynomials::value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ checkTwoDVectorParamsSameLength()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkTwoDVectorParamsSameLength ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that the two-D vectors have exactly the same length in both dimensions.

Parameters
param1first two-D vector parameter to check the dimensions of
param2second two-D vector parameter to check the dimensions of

Definition at line 71 of file InputParametersChecksUtils.h.

271{
272 checkVectorParamsSameLength<std::vector<T>, std::vector<S>>(param1, param2);
273 if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
274 {
275 const auto value1 = forwardGetParam<std::vector<std::vector<T>>>(param1);
276 const auto value2 = forwardGetParam<std::vector<std::vector<S>>>(param2);
277 for (const auto index : index_range(value1))
278 if (value1[index].size() != value2[index].size())
279 forwardParamError(
280 param1,
281 "Vector at index " + std::to_string(index) + " of 2D vector parameter '" + param1 +
282 "' is not the same size as its counterpart from 2D vector parameter '" + param2 +
283 "'.\nSize first vector: " + std::to_string(value1[index].size()) +
284 "\nSize second vector: " + std::to_string(value2[index].size()));
285 }
286 // handle empty vector defaults
287 else if (forwardIsParamValid(param1) || forwardIsParamValid(param2))
288 if (forwardGetParam<std::vector<T>>(param1).size() ||
289 forwardGetParam<std::vector<S>>(param2).size())
290 checkParamsBothSetOrNotSet(param1, param2);
291}
InputParametersChecksUtils< BatchMeshGeneratorAction >::checkParamsBothSetOrNotSet
void checkParamsBothSetOrNotSet(const std::string &param1, const std::string &param2) const
Check that two parameters are either both set or both not set.
Definition InputParametersChecksUtils.h:592

◆ checkVectorParamAndMultiMooseEnumLength()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkVectorParamAndMultiMooseEnumLength ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that this vector parameter (with name defined in param1) has the same length as the MultiMooseEnum (with name defined in param2)

Parameters
param1vector parameter to compare the size of
param2multiMooseEnum parameter to compare the size of

Definition at line 65 of file InputParametersChecksUtils.h.

245{
246 assertParamDefined<std::vector<T>>(param1);
247 assertParamDefined<MultiMooseEnum>(param2);
248
249 if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
250 {
251 const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
252 const auto size_2 = forwardGetParam<MultiMooseEnum>(param2).size();
253 if (size_1 != size_2)
254 forwardParamError(param1,
255 "Vector parameters '" + param1 + "' (size " + std::to_string(size_1) +
256 ") and '" + param2 + "' (size " + std::to_string(size_2) +
257 ") must be the same size");
258 }
259 // handle empty vector defaults
260 else if (forwardIsParamValid(param1) || forwardIsParamValid(param2))
261 if (forwardGetParam<std::vector<T>>(param1).size() ||
262 forwardGetParam<MultiMooseEnum>(param2).size())
263 checkParamsBothSetOrNotSet(param1, param2);
264}

◆ checkVectorParamLengthSameAsCombinedOthers()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkVectorParamLengthSameAsCombinedOthers ( const std::string &  param1,
const std::string &  param2,
const std::string &  param3 
) const
protectedinherited

Check that a vector parameter is the same length as two others combined.

Parameters
param1vector parameter that provides the target size
param2vector parameter that provides one term in the combined size
param3vector parameter that provides one term in the combined size

Definition at line 112 of file InputParametersChecksUtils.h.

348{
349 assertParamDefined<std::vector<T>>(param1);
350 assertParamDefined<std::vector<S>>(param2);
351 assertParamDefined<std::vector<U>>(param3);
352 const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
353 const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
354 const auto size_3 = forwardGetParam<std::vector<U>>(param3).size();
355
356 if (size_1 != size_2 + size_3)
357 forwardParamError(param1,
358 "Vector parameter '" + param1 + "' (size " + std::to_string(size_1) +
359 ") should be the same size as parameter '" + param2 + "' and '" + param3 +
360 " combined (total size " + std::to_string(size_2 + size_3) + ")");
361}

◆ checkVectorParamNotEmpty()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkVectorParamNotEmpty ( const std::string &  param1) const
protectedinherited

Check that the user did not pass an empty vector.

Parameters
param1vector parameter that should not be empty

Definition at line 99 of file InputParametersChecksUtils.h.

426{
427 assertParamDefined<std::vector<T>>(param);
428 if (!forwardGetParam<std::vector<T>>(param).size())
429 forwardParamError(param, "Parameter '" + param + "' should not be set to an empty vector.");
430}

◆ checkVectorParamsNoOverlap()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkVectorParamsNoOverlap ( const std::vector< std::string > &  param_vecs) const
protectedinherited

Check that there is no overlap between the items in each vector parameters Each vector parameter should also have unique items.

Parameters
param_vecsvector of parameters that should not overlap with each other

Definition at line 77 of file InputParametersChecksUtils.h.

368{
369 std::set<std::string> unique_params;
370 for (const auto & param : param_vec)
371 {
372 assertParamDefined<std::vector<T>>(param);
373
374 for (const auto & value : forwardGetParam<std::vector<T>>(param))
375 if (!unique_params.insert(value).second)
376 {
377 auto copy_params = param_vec;
378 copy_params.erase(std::find(copy_params.begin(), copy_params.end(), param));
379 // Overlap between multiple vectors of parameters
380 if (copy_params.size())
381 forwardMooseError("Item '" + value + "' specified in vector parameter '" + param +
382 "' is also present in one or more of the parameters '" +
383 Moose::stringify(copy_params) + "', which is not allowed.");
384 // Overlap within a single vector parameter caused by a repeated item
385 else
386 forwardMooseError("Item '" + value + "' specified in vector parameter '" + param +
387 "' is repeated, which is not allowed.");
388 }
389 }
390}

◆ checkVectorParamsSameLength()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkVectorParamsSameLength ( const std::string &  param1,
const std::string &  param2 
) const
protectedinherited

Check that the two vector parameters are of the same length.

Parameters
param1first vector parameter to compare the size of
param2second vector parameter to compare the size of

Definition at line 60 of file InputParametersChecksUtils.h.

219{
220 assertParamDefined<std::vector<T>>(param1);
221 assertParamDefined<std::vector<S>>(param2);
222
223 if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
224 {
225 const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
226 const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
227 if (size_1 != size_2)
228 forwardParamError(param1,
229 "Vector parameters '" + param1 + "' (size " + std::to_string(size_1) +
230 ") and '" + param2 + "' (size " + std::to_string(size_2) +
231 ") must be the same size");
232 }
233 // handle empty vector defaults
234 else if (forwardIsParamValid(param1) || forwardIsParamValid(param2))
235 if (forwardGetParam<std::vector<T>>(param1).size() ||
236 forwardGetParam<std::vector<S>>(param2).size())
237 checkParamsBothSetOrNotSet(param1, param2);
238}

◆ checkVectorParamsSameLengthIfSet()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::checkVectorParamsSameLengthIfSet ( const std::string &  param1,
const std::string &  param2,
const bool  ignore_empty_default_param2 = false 
) const
protectedinherited

Check that two vector parameters are the same length if both are set.

Parameters
param1first vector parameter to check the size of
param2second vector parameter to check the size of

Definition at line 104 of file InputParametersChecksUtils.h.

439{
440 assertParamDefined<std::vector<T>>(param1);
441 assertParamDefined<std::vector<S>>(param2);
442
443 if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
444 {
445 const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
446 const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
447 if (ignore_empty_default_param2 && (size_2 == 0) && !forwardIsParamSetByUser(param2))
448 return;
449 if (size_1 != size_2)
450 forwardParamError(param1,
451 "Parameter '" + param1 + "' (size " + std::to_string(size_1) + ") and '" +
452 param2 + "' (size " + std::to_string(size_2) +
453 ") must be the same size if set.");
454 }
455}

◆ connectControllableParams()

void MooseBase::connectControllableParams ( const std::string &  parameter,
const std::string &  object_type,
const std::string &  object_name,
const std::string &  object_parameter 
) const
inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters
parameterName of the controllable parameter of this action
object_typeType of the object added by this action.
object_nameName of the object added by this action.
object_parameterName of the parameter of the object.

Definition at line 77 of file MooseBase.C.

81{
82 auto & factory = _app.getFactory();
83 auto & ip_warehouse = _app.getInputParameterWarehouse();
84
85 MooseObjectParameterName primary_name(uniqueName(), parameter);
86 const auto base_type = factory.getValidParams(object_type).getBase();
87 MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
88 ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
89
90 const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
91 for (const auto & tag : tags)
92 {
93 if (!tag.empty())
94 {
95 // Only adds the parameter with the different control tags if the derived class
96 // properly registers the parameter to its own syntax
97 MooseObjectParameterName tagged_name(tag, name(), parameter);
98 ip_warehouse.addControllableParameterConnection(
99 tagged_name, secondary_name, /*error_on_empty=*/false);
100 }
101 }
102}
InputParameters::get
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.
Definition InputParameters.h:2342
MooseApp::getInputParameterWarehouse
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition MooseApp.C:2867
MooseBase::uniqueName
MooseObjectName uniqueName() const
Definition MooseBase.C:69
MooseObjectParameterName
A class for storing an input parameter name.
Definition MooseObjectParameterName.h:27

◆ convertAndSetCompoundRealScalarVector()

template<typename T >
void BatchMeshGeneratorAction::convertAndSetCompoundRealScalarVector ( InputParameters &  params,
const std::string &  param_name,
const std::vector< std::string > &  param_value 
) const
protected

Convert a vector of strings to a compound real scalar type vector and set it in the InputParameters object.

Parameters
paramsInputParameters object to set the parameter
param_nameName of the parameter to set
param_valueValue of the parameter to set in string format

Definition at line 802 of file BatchMeshGeneratorAction.C.

806{
807 std::vector<T> values(param_value.size());
808 std::transform(param_value.begin(),
809 param_value.end(),
810 values.begin(),
811 [this](const std::string & val)
812 { return convertStringToCompoundRealScalar<T>(val); });
813 params.set<std::vector<T>>(param_name) = values;
814}
values
std::array< Real, 2 > values
Definition MortarUtils.C:52

◆ convertAndSetNumericVector()

template<typename T >
void BatchMeshGeneratorAction::convertAndSetNumericVector ( InputParameters &  params,
const std::string &  param_name,
const std::vector< std::string > &  param_value 
) const
protected

Convert a vector of strings to a numeric vector and set it in the InputParameters object.

Parameters
paramsInputParameters object to set the parameter
param_nameName of the parameter to set
param_valueValue of the parameter to set in string format

Definition at line 787 of file BatchMeshGeneratorAction.C.

791{
792 std::vector<T> values(param_value.size());
793 std::transform(param_value.begin(),
794 param_value.end(),
795 values.begin(),
796 [](const std::string & val) { return MooseUtils::convert<T>(val); });
797 params.set<std::vector<T>>(param_name) = values;
798}

◆ convertAndSetStringLikeVector()

template<typename T >
void BatchMeshGeneratorAction::convertAndSetStringLikeVector ( InputParameters &  params,
const std::string &  param_name,
const std::vector< std::string > &  param_value 
) const
protected

Convert a vector of strings to a string-derived type vector and set it in the InputParameters object.

Parameters
paramsInputParameters object to set the parameter
param_nameName of the parameter to set
param_valueValue of the parameter to set in string format

Definition at line 818 of file BatchMeshGeneratorAction.C.

822{
823 std::vector<T> values(param_value.size());
824 std::transform(param_value.begin(),
825 param_value.end(),
826 values.begin(),
827 [](const std::string & val) { return T(val); });
828 params.set<std::vector<T>>(param_name) = values;
829}

◆ convertStringToCompoundRealScalar()

template<typename T >
T BatchMeshGeneratorAction::convertStringToCompoundRealScalar ( const std::string &  str) const
protected

Convert a string to a compound real scalar type.

Parameters
strString to convert
Returns
Converted compound real scalar type

Definition at line 948 of file BatchMeshGeneratorAction.C.

949{
950 const auto split_str = MooseUtils::split(str, " ");
951 mooseAssert(split_str.size() == Moose::dim,
952 "string used for compound real scalar conversion should contain three elements.");
953 T ret(MooseUtils::convert<Real>(split_str[0]));
954 for (const auto i :
955 make_range(static_cast<std::remove_cv_t<decltype(Moose::dim)>>(1), Moose::dim))
956 ret(i) = MooseUtils::convert<Real>(split_str[i]);
957 return ret;
958}
MooseUtils::convert
bool convert(const std::string &str, T &value, const bool throw_on_failure)
Takes the string representation of a value and converts it to the value.
Definition MooseStringUtils.h:96
MooseUtils::split
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count)
Definition MooseUtils.C:1031
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ errorDependentParameter()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::errorDependentParameter ( const std::string &  param1,
const std::string &  value_not_set,
const std::vector< std::string > &  dependent_params 
) const
protectedinherited

Error messages for parameters that should depend on another parameter.

Parameters
param1the parameter has not been set to the desired value (for logging purposes)
value_not_setthe desired value (for logging purposes)
dependent_paramsall the parameters that should not have been since 'param1' was not set to 'value_not_set'

Definition at line 137 of file InputParametersChecksUtils.h.

566{
567 for (const auto & dependent_param : dependent_params)
568 if (forwardIsParamSetByUser(dependent_param))
569 forwardParamError(dependent_param,
570 "Parameter '" + dependent_param +
571 "' should not be set by the user if parameter '" + param1 +
572 "' has not been set to '" + value_not_set + "'");
573}

◆ errorInconsistentDependentParameter()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::errorInconsistentDependentParameter ( const std::string &  param1,
const std::string &  value_set,
const std::vector< std::string > &  dependent_params 
) const
protectedinherited

Error messages for parameters that should depend on another parameter but with a different error message.

Parameters
param1the parameter has not been set to the desired value (for logging purposes)
value_setthe value it has been set to and which is not appropriate (for logging purposes)
dependent_paramsall the parameters that should not have been set since 'param1' was set to 'value_set'

Definition at line 144 of file InputParametersChecksUtils.h.

581{
582 for (const auto & dependent_param : dependent_params)
583 if (forwardIsParamSetByUser(dependent_param))
584 forwardParamError(dependent_param,
585 "Parameter '" + dependent_param +
586 "' should not be set by the user if parameter '" + param1 +
587 "' has been set to '" + value_set + "'");
588}

◆ errorPrefix()

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

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ flagInvalidSolutionInternal()

template<bool warning>
template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID  invalid_solution_id) const
protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

43{
44 mooseAssert(
45 warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
46 "Inconsistent warning flag");
47 auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
48 if constexpr (!warning)
49 if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
50 solution_invalidity.printDebug(invalid_solution_id);
51 return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
52}
FEProblemBase::immediatelyPrintInvalidSolution
bool immediatelyPrintInvalidSolution() const
Whether or not the solution invalid warnings are printed out immediately.
Definition FEProblemBase.h:2416
MooseApp::solutionInvalidity
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
Definition MooseApp.h:185
MooseBase::getMooseApp
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition MooseBase.h:87
SolutionInvalidInterface::_si_problem
const FEProblemBase * _si_problem
A pointer to FEProblem base.
Definition SolutionInvalidInterface.h:114
SolutionInvalidInterface::_si_moose_base
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
Definition SolutionInvalidInterface.h:111
SolutionInvalidity::printDebug
void printDebug(InvalidSolutionID _invalid_solution_id) const
Immediately print the section and message for debug purpose.
Definition SolutionInvalidity.C:208
moose::internal::getSolutionInvalidityRegistry
SolutionInvalidityRegistry & getSolutionInvalidityRegistry()
Get the global SolutionInvalidityRegistry singleton.
Definition SolutionInvalidityRegistry.C:18

◆ forwardBlocks()

const std::vector< SubdomainName > & InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardBlocks ( ) const
inlineprivateinherited

Get the blocks for the class using this utility.

Definition at line 192 of file InputParametersChecksUtils.h.

193 {
194 // TODO Use SFINAE to create a version for classes that do not define blocks()
195 // TODO Use SFINAE to force blocks() to return a reference as well
196 return _customer_class->blocks();
197 }

◆ forwardGetParam()

const T & InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardGetParam ( const std::string &  param_name) const
inlineprivateinherited

Forwards parameter check to the class using this utility.

Definition at line 153 of file InputParametersChecksUtils.h.

154 {
155 return _customer_class->template getParam<T>(param_name);
156 }

◆ forwardIsParamSetByUser()

bool InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardIsParamSetByUser ( const std::string &  param_name) const
inlineprivateinherited

Forwards parameter check to the class using this utility.

Definition at line 160 of file InputParametersChecksUtils.h.

161 {
162 return _customer_class->isParamSetByUser(param_name);
163 }
MooseBase::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
Definition MooseBase.h:205

◆ forwardIsParamValid()

bool InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardIsParamValid ( const std::string &  param_name) const
inlineprivateinherited

Forwards parameter check to the class using this utility.

Definition at line 165 of file InputParametersChecksUtils.h.

166 {
167 return _customer_class->isParamValid(param_name);
168 }

◆ forwardMooseError()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardMooseError ( Args &&...  args) const
inlineprivateinherited

Forwards error to the class using this utility to get better error messages.

Definition at line 177 of file InputParametersChecksUtils.h.

178 {
179 _customer_class->mooseError(std::forward<Args>(args)...);
180 }

◆ forwardMooseWarning()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardMooseWarning ( Args &&...  args) const
inlineprivateinherited

Forwards warning to the class using this utility to get better error messages.

Definition at line 183 of file InputParametersChecksUtils.h.

184 {
185 _customer_class->mooseWarning(std::forward<Args>(args)...);
186 }
SolutionInvalidInterface::mooseWarning
void mooseWarning(Args &&... args) const
Definition SolutionInvalidInterface.h:73

◆ forwardName()

virtual const std::string & InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardName ( ) const
inlineprivatevirtualinherited

Get the name of the class using this utility.

Definition at line 190 of file InputParametersChecksUtils.h.

190{ return _customer_class->name(); }

◆ forwardParamError()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardParamError ( Args &&...  args) const
inlineprivateinherited

Forwards error to the class using this utility to get better error messages.

Definition at line 171 of file InputParametersChecksUtils.h.

172 {
173 _customer_class->paramError(std::forward<Args>(args)...);
174 }

◆ forwardParameters()

const InputParameters & InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardParameters ( ) const
inlineprivateinherited

Forwards obtaining parameters to the class using this utility.

Definition at line 158 of file InputParametersChecksUtils.h.

158{ return _customer_class->parameters(); }

◆ forwardType()

const std::string & InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardType ( ) const
inlineprivateinherited

Get the type of the class using this utility.

Definition at line 188 of file InputParametersChecksUtils.h.

188{ return _customer_class->type(); }

◆ getAllTasks()

const std::set< std::string > & Action::getAllTasks ( ) const
inlineinherited

Definition at line 112 of file Action.h.

112{ return _all_tasks; }

Referenced by AddKernelAction::act().

◆ getBase()

const std::string & MooseBase::getBase ( ) const
inlineinherited
Returns
The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

◆ getCheckedPointerParam()

template<typename T >
T MooseBase::getCheckedPointerParam ( const std::string &  name,
const std::string &  error_string = "" 
) const
inherited

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

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

Definition at line 450 of file MooseBase.h.

451{
452 return _pars.getCheckedPointerParam<T>(name, error_string);
453}
InputParameters::getCheckedPointerParam
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.
Definition InputParameters.h:1790

◆ getDataFileName()

std::string DataFileInterface::getDataFileName ( const std::string &  param) const
inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

22{
23 _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
24 "within the InputParameters.\nUse getParam<DataFileName>(\"",
25 param,
26 "\") instead.");
27 return _parent.getParam<DataFileName>(param);
28}
DataFileInterface::_parent
const ParallelParamObject & _parent
Definition DataFileInterface.h:58
MooseBase::mooseDeprecated
void mooseDeprecated(Args &&... args) const
Emits a deprecation warning prefixed with the object name and type, and a stack trace.
Definition MooseBase.h:317

◆ getDataFileNameByName()

std::string DataFileInterface::getDataFileNameByName ( const std::string &  relative_path) const
inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

32{
33 _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
34 relative_path,
35 "\") instead.");
36 return getDataFilePath(relative_path);
37}
DataFileInterface::getDataFilePath
std::string getDataFilePath(const std::string &relative_path) const
Returns the path of a data file for a given relative file path.
Definition DataFileInterface.C:40

◆ getDataFilePath()

std::string DataFileInterface::getDataFilePath ( const std::string &  relative_path) const
inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

41{
42 // This should only ever be used with relative paths. There is no point to
43 // use this search path with an absolute path.
44 if (std::filesystem::path(relative_path).is_absolute())
45 _parent.mooseWarning("While using getDataFilePath(\"",
46 relative_path,
47 "\"): This API should not be used for absolute paths.");
48
49 // This will search the data paths for this relative path
50 std::optional<std::string> error;
51 Moose::DataFileUtils::Path found_path;
52 {
53 // Throw on error so that if getPath() fails, we can throw an error
54 // with the context of _parent.mooseError()
55 Moose::ScopedThrowOnError scoped_throw_on_error;
56
57 try
58 {
59 found_path = Moose::DataFileUtils::getPath(relative_path);
60 }
61 catch (std::exception & e)
62 {
63 error = e.what();
64 }
65 }
66
67 if (error)
68 _parent.mooseError(*error);
69
70 mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
71 "Should only ever obtain data");
72 mooseAssert(found_path.data_name, "Should be set");
73
74 const std::string msg =
75 "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
76 _parent.mooseInfo(msg);
77
78 return found_path.path;
79}
MooseBase::mooseWarning
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition MooseBase.h:299
MooseBase::mooseInfo
void mooseInfo(Args &&... args) const
Definition MooseBase.h:334
Moose::ScopedThrowOnError
Scoped helper for setting Moose::_throw_on_error during this scope.
Definition Moose.h:298
Moose::DataFileUtils::Context::DATA
@ DATA
From installed/in-tree data.
Moose::DataFileUtils::getPath
Path getPath(std::string path, const GetPathOptions &options={})
Get the data path for a given path, searching the registered data.
Definition DataFileUtils.C:22
Moose::DataFileUtils::Path
Representation of a data file path.
Definition DataFileUtils.h:41
Moose::DataFileUtils::Path::data_name
std::optional< std::string > data_name
The name of the data registry the file came from (with context == DATA)
Definition DataFileUtils.h:54
Moose::DataFileUtils::Path::context
Context context
Context for the file (where it came from)
Definition DataFileUtils.h:52

Referenced by DataFileInterface::getDataFileNameByName().

◆ getHitNode() [1/2]

const hit::Node * MooseBase::getHitNode ( ) const
inlineinherited
Returns
The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

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

◆ getHitNode() [2/2]

const hit::Node * MooseBase::getHitNode ( const InputParameters &  params)
staticprivateinherited

Internal method for getting a hit node (if available) given a set of parameters.

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 167 of file MooseBase.C.

168{
169 if (const auto hit_node = params.getHitNode())
170 if (!hit_node->isRoot())
171 return hit_node;
172 return nullptr;
173}

◆ getMeshProperty() [1/2]

template<typename T >
const T & MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name)
inlineprotectedinherited

Definition at line 64 of file MeshMetaDataInterface.h.

65 {
66 return getMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
67 }
MeshMetaDataInterface::meshPropertyPrefix
virtual std::string meshPropertyPrefix(const std::string &data_name) const
The default prefix to use for getting/seeing if mesh properties exist.
Definition MeshMetaDataInterface.C:47

◆ getMeshProperty() [2/2]

template<typename T >
const T & MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name,
const std::string &  prefix 
)
protectedinherited

Method for retrieving a property with the given type and name exists in the mesh meta-data store.

This method will throw an error if the property does not exist.

Definition at line 142 of file MeshMetaDataInterface.h.

144{
145 if (!hasMeshProperty(data_name, prefix))
146 mooseErrorInternal("Failed to get mesh property '", prefix, "/", data_name, "'");
147
148 auto value = &getMeshPropertyInternal(data_name, prefix);
149 mooseAssert(value->declared(), "Value has not been declared");
150 const RestartableData<T> * T_value = dynamic_cast<const RestartableData<T> *>(value);
151 if (!T_value)
152 mooseErrorInternal("While retrieving mesh property '",
153 prefix,
154 "/",
155 data_name,
156 "' with type '",
157 MooseUtils::prettyCppType<T>(),
158 "',\nthe property exists with different type '",
159 value->type(),
160 "'");
161 return T_value->get();
162}
MeshMetaDataInterface::hasMeshProperty
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
Definition MeshMetaDataInterface.C:33
MeshMetaDataInterface::getMeshPropertyInternal
const RestartableDataValue & getMeshPropertyInternal(const std::string &data_name, const std::string &prefix) const
Helper for getting a mesh property.
Definition MeshMetaDataInterface.C:54
MeshMetaDataInterface::mooseErrorInternal
void mooseErrorInternal(Args &&... args) const
Helper for forwarding a mooseError to an object's mooseError if it is available (said error will prov...
Definition MeshMetaDataInterface.h:132
RestartableData
Concrete definition of a parameter value for a specified type.
Definition RestartableData.h:216
RestartableData::get
const T & get() const
Definition RestartableData.h:280

◆ getMeshPropertyInternal()

const RestartableDataValue & MeshMetaDataInterface::getMeshPropertyInternal ( const std::string &  data_name,
const std::string &  prefix 
) const
privateinherited

Helper for getting a mesh property.

Definition at line 54 of file MeshMetaDataInterface.C.

56{
57 return _meta_data_app.getRestartableMetaData(
58 meshPropertyName(data_name, prefix), MooseApp::MESH_META_DATA, 0);
59}
MeshMetaDataInterface::_meta_data_app
MooseApp & _meta_data_app
Reference to the application.
Definition MeshMetaDataInterface.h:122
MeshMetaDataInterface::meshPropertyName
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
Definition MeshMetaDataInterface.C:41
MooseApp::getRestartableMetaData
RestartableDataValue & getRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname, THREAD_ID tid)
Definition MooseApp.C:2511
MooseApp::MESH_META_DATA
static const RestartableDataMapName MESH_META_DATA
Definition MooseApp.h:136

Referenced by MeshMetaDataInterface::getMeshProperty(), and MeshMetaDataInterface::hasMeshProperty().

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const
inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

◆ getParam() [1/2]

template<typename T >
const T & MooseBase::getParam ( const std::string &  name) const
inherited

Retrieve a parameter for the object.

Parameters
nameThe name of the parameter
Returns
The value of the parameter

Definition at line 406 of file MooseBase.h.

407{
408 return InputParameters::getParamHelper<T>(name, _pars);
409}

Referenced by CommonOutputAction::act(), CreateDisplacedProblemAction::act(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), Console::Console(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), ParsedSubdomainGeneratorBase::functionInitialize(), BlockDeletionGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FileMeshGenerator::generate(), MeshExtruderGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), XYDelaunayGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), AdvancedOutput::init(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), AdvancedOutput::initAvailableLists(), AttribThread::initFrom(), AttribExecutionOrderGroup::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), ReferenceResidualInterface::ReferenceResidualInterface(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), PetscOutput::solveSetup(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

◆ getParam() [2/2]

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > > MooseBase::getParam ( const std::string &  param1,
const std::string &  param2 
) const
inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters
param1The name of first parameter
param2The name of second parameter
Returns
Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

444{
445 return _pars.get<T1, T2>(param1, param2);
446}

◆ getRenamedParam()

template<typename T >
const T & MooseBase::getRenamedParam ( const std::string &  old_name,
const std::string &  new_name 
) const
inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters
old_namethe old name for the parameter
new_namethe new name for the parameter

Definition at line 420 of file MooseBase.h.

421{
422 // Most important: accept new parameter
423 if (isParamSetByUser(new_name) && !isParamValid(old_name))
424 return getParam<T>(new_name);
425 // Second most: accept old parameter
426 if (isParamValid(old_name) && !isParamSetByUser(new_name))
427 return getParam<T>(old_name);
428 // Third most: accept default for new parameter
429 if (isParamValid(new_name) && !isParamValid(old_name))
430 return getParam<T>(new_name);
431 // Refuse: no default, no value passed
432 if (!isParamValid(old_name) && !isParamValid(new_name))
433 mooseError("parameter '" + new_name +
434 "' is being retrieved without being set.\nDid you misspell it?");
435 // Refuse: both old and new parameters set by user
436 else
437 mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
438 old_name + "'");
439}

◆ hasBase()

bool MooseBase::hasBase ( ) const
inlineinherited
Returns
Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }
InputParameters::hasBase
bool hasBase() const
Definition InputParameters.C:499

◆ hasMeshProperty() [1/4]

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name) const
inlineprotectedinherited
Returns
Whether or not a mesh meta-data exists with the default prefix.

Definition at line 82 of file MeshMetaDataInterface.h.

83 {
84 return hasMeshProperty(data_name, meshPropertyPrefix(data_name));
85 }

◆ hasMeshProperty() [2/4]

template<typename T >
bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name) const
inlineprotectedinherited
Returns
Whether or not a mesh meta-data exists with the default prefix and the given type.

Definition at line 90 of file MeshMetaDataInterface.h.

91 {
92 return hasMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
93 }

◆ hasMeshProperty() [3/4]

bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name,
const std::string &  prefix 
) const
protectedinherited
Returns
Whether or not a mesh meta-data exists.

Definition at line 33 of file MeshMetaDataInterface.C.

35{
36 return _meta_data_app.hasRestartableMetaData(meshPropertyName(data_name, prefix),
37 MooseApp::MESH_META_DATA);
38}
MooseApp::hasRestartableMetaData
bool hasRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname) const
Definition MooseApp.C:2501

Referenced by MeshGenerator::declareMeshProperty(), MeshMetaDataInterface::getMeshProperty(), MeshMetaDataInterface::hasMeshProperty(), MeshMetaDataInterface::hasMeshProperty(), and MeshGenerator::setMeshProperty().

◆ hasMeshProperty() [4/4]

template<typename T >
bool MeshMetaDataInterface::hasMeshProperty ( const std::string &  data_name,
const std::string &  prefix 
) const
protectedinherited
Returns
Whether or not a mesh meta-data exists with the given type.

Definition at line 166 of file MeshMetaDataInterface.h.

168{
169 if (!hasMeshProperty(data_name, prefix))
170 return false;
171 const auto & value = getMeshPropertyInternal(data_name, prefix);
172 return dynamic_cast<const RestartableData<T> *>(&value) != nullptr;
173}

◆ isCompoundRealScalarType()

bool BatchMeshGeneratorAction::isCompoundRealScalarType ( const ParameterType &  param_type) const
protected

Check if the parameter type is a compound real scalar type.

Parameters
param_typeParameter type to check
Returns
True if the parameter type is a compound real scalar type, false otherwise

Definition at line 961 of file BatchMeshGeneratorAction.C.

962{
963 const auto valid_types = {ParameterType::REALVECTORVALUE, ParameterType::POINT};
964 return std::count(valid_types.begin(), valid_types.end(), param_type);
965}

Referenced by BatchMeshGeneratorAction().

◆ isParamSetByUser()

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

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

Parameters
nameThe name of the parameter to test

Definition at line 205 of file MooseBase.h.

206 {
207 return _pars.isParamSetByUser(name);
208 }
InputParameters::isParamSetByUser
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.
Definition InputParameters.C:1293

Referenced by DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ isParamValid()

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

Test if the supplied parameter is valid.

Parameters
nameThe name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }
InputParameters::isParamValid
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another,...
Definition InputParameters.C:386

Referenced by GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), AddVariableAction::act(), AutoCheckpointAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CopyNodalVarsAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentJunction::ComponentJunction(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenProblemSolve::EigenProblemSolve(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), BlockDeletionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BSplineCurveGenerator::generate(), ConcentricCircleMeshGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshExtruderGenerator::generate(), OrientSurfaceMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), SphereMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), AddPeriodicBCAction::getVariables(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), SolutionAux::initialSetup(), SolutionScalarAux::initialSetup(), PIDTransientControl::initialSetup(), ParsedConvergence::initialSetup(), EigenProblemSolve::initialSetup(), MooseParsedFunction::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedVectorFunction::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionIC::initialSetup(), Console::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), PNGOutput::makePNG(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), EqualValueBoundaryConstraint::pickPrimaryNode(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), MooseMesh::prepare(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusIIOrNemesis(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, T >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), PIDTransientControl::timestepSetup(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ meshPropertyName() [1/2]

std::string MeshMetaDataInterface::meshPropertyName ( const std::string &  data_name) const
inlineprotectedinherited
Returns
The default mesh property name for mesh property data

Definition at line 103 of file MeshMetaDataInterface.h.

104 {
105 return meshPropertyName(data_name, meshPropertyPrefix(data_name));
106 }

◆ meshPropertyName() [2/2]

std::string MeshMetaDataInterface::meshPropertyName ( const std::string &  data_name,
const std::string &  prefix 
)
staticprotectedinherited
Returns
The full name for mesh property data.

Definition at line 41 of file MeshMetaDataInterface.C.

42{
43 return std::string(SYSTEM) + "/" + prefix + "/" + data_name;
44}
MeshMetaDataInterface::SYSTEM
static constexpr auto SYSTEM
The system name used when initializing the Restartable interface.
Definition MeshMetaDataInterface.h:30

Referenced by MeshGenerator::declareMeshProperty(), MeshMetaDataInterface::getMeshPropertyInternal(), MeshMetaDataInterface::hasMeshProperty(), MeshMetaDataInterface::meshPropertyName(), and MeshGenerator::setMeshPropertyHelper().

◆ meshPropertyPrefix()

std::string MeshMetaDataInterface::meshPropertyPrefix ( const std::string &  data_name) const
privatevirtualinherited

The default prefix to use for getting/seeing if mesh properties exist.

For now, this is not supported except in MeshGenerators. In the future, we will automate looking for mesh properties.

Reimplemented in MeshGenerator.

Definition at line 47 of file MeshMetaDataInterface.C.

48{
49 mooseError("This object does not support obtaining a mesh property without a prefix.\n\nThis "
50 "capability is upcoming.");
51}
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application.
Definition MooseError.h:311

Referenced by MeshMetaDataInterface::getMeshProperty(), MeshMetaDataInterface::hasMeshProperty(), and MeshMetaDataInterface::meshPropertyName().

◆ messagePrefix() [1/2]

std::string MooseBase::messagePrefix ( const bool  hit_prefix = true) const
inlineinherited
Returns
A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

257 {
258 return messagePrefix(_pars, hit_prefix);
259 }

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::messagePrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

◆ messagePrefix() [2/2]

std::string MooseBase::messagePrefix ( const InputParameters &  params,
const bool  hit_prefix 
)
staticprivateinherited

Internal method for getting the message prefix for an object (object type, name, etc).

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 140 of file MooseBase.C.

141{
142 std::string prefix = "";
143
144 if (hit_prefix)
145 if (const auto node = MooseBase::getHitNode(params))
146 prefix += Moose::hitMessagePrefix(*node);
147
148 // Don't have context without type and name
149 if (!params.isMooseBaseObject())
150 return prefix;
151
152 const auto & name = params.getObjectName();
153 const std::string base = params.hasBase() ? params.getBase() : "object";
154 const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
155 prefix += "The following occurred in the ";
156 if (is_main_app)
157 prefix += "main " + base;
158 else
159 prefix += base;
160 if (base != params.getObjectName() && name.size() && !is_main_app)
161 prefix += " '" + name + "'";
162 prefix += " of type " + params.getObjectType() + ".";
163 return prefix + "\n\n";
164}
AppFactory::main_app_name
static const std::string main_app_name
The name for the "main" moose application.
Definition AppFactory.h:68
InputParameters::isMooseBaseObject
bool isMooseBaseObject() const
Definition InputParameters.C:995
InputParameters::getObjectType
const std::string & getObjectType() const
Definition InputParameters.C:1011
InputParameters::getObjectName
const std::string & getObjectName() const
Definition InputParameters.C:1019
Moose::hitMessagePrefix
std::string hitMessagePrefix(const hit::Node &node)
Get the prefix to be associated with a hit node for a message.
Definition Moose.C:883

◆ mooseDeprecated() [1/2]

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

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 317 of file MooseBase.h.

318 {
319 moose::internal::mooseDeprecatedStream(
320 _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
321 }
ConsoleStreamInterface::_console
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
Definition ConsoleStreamInterface.h:31
moose::internal::mooseDeprecatedStream
void mooseDeprecatedStream(S &oss, const bool expired, const bool print_title, const bool show_trace, Args &&... args)
Definition MooseError.h:252

Referenced by MooseApp::addCapability(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), and MooseApp::setupOptions().

◆ mooseDeprecated() [2/2]

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

Definition at line 87 of file SolutionInvalidInterface.h.

88 {
89 _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
90 flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
91 }

Referenced by MultiApp::appProblem(), AddVariableAction::determineType(), MooseMesh::elem(), MooseMesh::elem(), FunctionDT::FunctionDT(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicDistance(), MooseMesh::minPeriodicVector(), MooseMesh::node(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), and MooseMesh::setBoundaryToNormalMap().

◆ mooseDeprecatedNoTrace()

template<typename... Args>
void MooseBase::mooseDeprecatedNoTrace ( Args &&...  args) const
inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 327 of file MooseBase.h.

328 {
329 moose::internal::mooseDeprecatedStream(
330 _console, false, true, false, messagePrefix(true), std::forward<Args>(args)...);
331 }

◆ mooseDocumentedError()

template<typename... Args>
void MooseBase::mooseDocumentedError ( const std::string &  repo_name,
const unsigned int  issue_num,
Args &&...  args 
) const
inlineinherited

Definition at line 277 of file MooseBase.h.

280 {
281 callMooseError(moose::internal::formatMooseDocumentedError(
282 repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
283 /* with_prefix = */ true);
284 }
moose::internal::formatMooseDocumentedError
std::string formatMooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, const std::string &msg)
Formats a documented error.
Definition MooseError.C:142

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>
void MooseBase::mooseError ( Args &&...  args) const
inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

272 {
273 callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
274 }

Referenced by CopyMeshPartitioner::_do_partition(), GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), AdaptivityAction::act(), AddBoundsVectorsAction::act(), AddFVICAction::act(), AddICAction::act(), AddMeshGeneratorAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), AddVectorPostprocessorAction::act(), ChainControlSetupAction::act(), CheckFVBCAction::act(), CheckIntegrityAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), InitProblemAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SplitMeshAction::act(), Action::Action(), AddActionComponentAction::AddActionComponentAction(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), MooseApp::addCapabilityInternal(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), SubProblem::addFunctor(), PhysicsComponentInterface::addInitialConditionsFromComponents(), ComponentJunction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), AddActionComponentAction::addRelationshipManagers(), WebServerControl::addServerAction(), AddVariableAction::addVariable(), SubProblem::addVectorTag(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), MooseVariableBase::allDofIndices(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), MooseApp::attachRelationshipManagers(), MooseApp::attachRelationshipManagers(), FEProblemBase::automaticScaling(), Function::average(), BatchMeshGeneratorAction(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), PiecewiseTabularInterface::buildFromXY(), MooseMesh::buildLowerDMesh(), GeneratedMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), TiledMesh::buildMesh(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), Moose::PeriodicBCHelper::checkPeriodicParams(), Sampler::checkReinitStatus(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Moose::PetscSupport::checkUserProvidedPetscOption(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), MooseMesh::clone(), LibmeshPartitioner::clone(), CombinerGenerator::CombinerGenerator(), MooseVariableFieldBase::componentName(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), MooseVariableFieldBase::computeFaceValues(), TimeStepper::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MaterialBase::computeProperties(), FVFluxBC::computeResidual(), ResidualObject::computeResidualAndJacobian(), TimeStepper::computeStep(), AStableDirk4::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyInternal(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), MooseApp::determineLibtorchDeviceType(), MeshDiagnosticsGenerator::diagnosticsLog(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), FunctorRelationshipManager::dofmap_reinit(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), DistributedRectilinearMeshGenerator::elemId(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), FixedPointSolve::examineFixedPointConvergence(), Eigenvalue::execute(), TransientBase::execute(), WebServerControl::execute(), MooseApp::executeExecutioner(), MultiApp::fillPositions(), MooseApp::finalizeRestore(), Transfer::find_sys(), DiracKernelInfo::findPoint(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), LinearFVBoundaryCondition::functorFaceArg(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), AdvancedExtruderGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), CoarsenBlockGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), DistributedRectilinearMeshGenerator::generate(), ElementOrderConversionGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshCollectionGenerator::generate(), MeshDiagnosticsGenerator::generate(), MeshExtruderGenerator::generate(), MeshRepairGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SmoothMeshGenerator::generate(), SpiralAnnularMeshGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), MooseMesh::getAxisymmetricRadialCoord(), MooseMesh::getBlockConnectedBlocks(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), WebServerControl::getClientInfo(), MooseMesh::getCoarseningMap(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PhysicsBase::getCoupledPhysics(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), WebServerControl::Response::getError(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), SubProblem::getFunctor(), MooseMesh::getGeneralAxisymmetricCoordAxis(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), MaterialPropertyInterface::getKokkosBlockMaterialProperty(), FunctionInterface::getKokkosFunctionByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), Material::getMaterialByName(), SubProblem::getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), DistributedRectilinearMeshGenerator::getNeighbors(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), PlaneIDMeshGenerator::getPlaneID(), PostprocessorInterface::getPostprocessorValueByNameInternal(), ComponentMaterialPropertyInterface::getPropertyValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), MooseObject::getSharedPtr(), MooseObject::getSharedPtr(), PhysicsBase::getSolverSystem(), MooseMesh::getSubdomainBoundaryIds(), TransientBase::getTimeIntegratorNames(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), AddPeriodicBCAction::getVariables(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), MultiApp::globalAppToLocal(), Function::gradient(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), TransientBase::incrementStepOrReject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), EigenExecutionerBase::init(), TransientBase::init(), CrankNicolson::init(), ExplicitTimeIntegrator::init(), FixedPointIterationAdaptiveDT::init(), IterationAdaptiveDT::init(), MultiApp::init(), NestedDivision::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SubProblem::initialSetup(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), FullSolveMultiApp::initialSetup(), ExplicitTimeIntegrator::initialSetup(), Function::integral(), InternalSideIndicatorBase::InternalSideIndicatorBase(), EigenExecutionerBase::inversePowerIteration(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LineSearch::lineSearch(), MooseApp::loadLibraryAndDependencies(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), Material::Material(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableBase::MooseVariableBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppTransfer::MultiAppTransfer(), NewmarkBeta::NewmarkBeta(), DistributedRectilinearMeshGenerator::nodeId(), DistributedRectilinearMeshGenerator::numNeighbors(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), MortarNodalGeometryOutput::output(), Output::Output(), MooseApp::outputMachineReadableData(), DistributedRectilinearMeshGenerator::paritionSquarely(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularInterface::PiecewiseTabularInterface(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), ProjectSideSetOntoLevelSetGenerator::pointPairLevelSetInterception(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), ExplicitTVDRK2::postResidual(), ImplicitMidpoint::postResidual(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), LStableDirk4::postResidual(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), FixedPointSolve::printFixedPointConvergenceReason(), MultiApp::readCommandLineArguments(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), ScalarComponentIC::ScalarComponentIC(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), MooseMesh::setGeneralAxisymmetricCoordAxes(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), Split::setup(), TransientMultiApp::setupApp(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SmoothMeshGenerator::SmoothMeshGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), Moose::MFEM::LinearSolverBase::Solve(), TimeIntegrator::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), FullSolveMultiApp::solveStep(), UserObject::spatialPoints(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), MeshRepairGenerator::splitNonConvexPolygons(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), MaterialBase::subdomainSetup(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), Action::timedAct(), Function::timeDerivative(), Function::timeIntegral(), ParsedCurveGenerator::tSectionSpaceDefiner(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), MooseVariableScalar::uDotOld(), MooseBase::uniqueName(), AuxScalarKernel::uOld(), ScalarKernelBase::uOld(), Function::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), AddVariableAction::variableType(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), WebServerControl::WebServerControl(), and MooseApp::writeRestartableMetaData().

◆ mooseErrorInternal()

template<typename... Args>
void MeshMetaDataInterface::mooseErrorInternal ( Args &&...  args) const
inlineprivateinherited

Helper for forwarding a mooseError to an object's mooseError if it is available (said error will provide more context: object name and type)

Definition at line 132 of file MeshMetaDataInterface.h.

133 {
134 if (_meta_data_object)
135 _meta_data_object->mooseError(std::forward<Args>(args)...);
136 mooseError(std::forward<Args>(args)...);
137 }
MeshMetaDataInterface::_meta_data_object
const MooseObject *const _meta_data_object
The MooseObject (if any); used for better error handling.
Definition MeshMetaDataInterface.h:125

Referenced by MeshMetaDataInterface::getMeshProperty().

◆ mooseErrorNonPrefixed()

template<typename... Args>
void MooseBase::mooseErrorNonPrefixed ( Args &&...  args) const
inlineinherited

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

Definition at line 290 of file MooseBase.h.

291 {
292 callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
293 }

◆ mooseInfo()

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

Definition at line 334 of file MooseBase.h.

335 {
336 moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
337 }
moose::internal::mooseInfoStream
void mooseInfoStream(S &oss, Args &&... args)
Definition MooseError.h:245

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), MooseApp::setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

◆ mooseWarning() [1/2]

template<typename... Args>
void MooseBase::mooseWarning ( Args &&...  args) const
inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

300 {
301 moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
302 }
moose::internal::mooseWarningStream
void mooseWarningStream(S &oss, Args &&... args)
Definition MooseError.h:197

Referenced by DiracKernelInfo::findPoint(), DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), and MooseBase::paramWarning().

◆ mooseWarning() [2/2]

template<typename... Args>
void SolutionInvalidInterface::mooseWarning ( Args &&...  args) const
inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

74 {
75 _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
76 flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
77 }

Referenced by CopyMeshPartitioner::_do_partition(), AddFunctionAction::act(), AddKernelAction::act(), CommonOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), MooseMesh::addPeriodicVariable(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkPolygons(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), BSplineCurveGenerator::generate(), RenumberBySubdomainGenerator::generate(), SubdomainPerElementGenerator::generate(), SurfaceMeshGeneratorBase::get2DElemNormal(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), MFEMRefinementMarker::initialSetup(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), MooseMesh::setCoordSystem(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>
void MooseBase::mooseWarningNonPrefixed ( Args &&...  args) const
inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>
void SolutionInvalidInterface::mooseWarningNonPrefixed ( Args &&...  args) const
inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

81 {
82 _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
83 flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
84 }

◆ name()

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

Get the name of the class.

Returns
The name of the class

Definition at line 103 of file MooseBase.h.

104 {
105 mooseAssert(_name.size(), "Empty name");
106 return _name;
107 }

Referenced by AdaptivityAction::act(), AddActionComponentAction::act(), AddElementalFieldAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), CommonOutputAction::act(), CopyNodalVarsAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), SetupResidualDebugAction::act(), SetupTimeIntegratorAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), FEProblemBase::addAuxKernel(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), MFEMProblem::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), FEProblemBase::addIndicator(), MFEMProblem::addIndicator(), FEProblemBase::addInitialCondition(), MFEMProblem::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), ElementAndTraceScalarHDGAssemblyHelper::additionalROVariables(), BoundaryIntegralValueConstraint::additionalROVariables(), DiffusionLHDGKernel::additionalROVariables(), ADKernelScalarBase::additionalROVariables(), FEProblemBase::addKernel(), MFEMProblem::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), MFEMProblem::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), InitialConditionWarehouse::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), UserObjectBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), InitialConditionBase::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addQuadratureFunction(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), AddActionComponentAction::addRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), MFEMProblem::addTransfer(), PhysicsBase::addUserObject(), FEProblemBase::addUserObject(), UserObjectBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), InitialConditionBase::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), MFEMProblem::addVectorPostprocessor(), UserObjectBase::addVectorPostprocessorDependencyHelper(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< OutputType >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), NEML2ModelExecutor::advanceState(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), Function::average(), MultiApp::backup(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromXY(), MFEMGeometricMultigridSolver::BuildMultigrid(), MooseMesh::buildNodeListFromSideList(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), DefaultNonlinearConvergence::checkConvergence(), ParsedConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), TaggingInterface::checkForNans(), SamplerBase::checkForStandardFieldVariableType(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), NonlinearSystemBase::checkKernelCoverage(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), FEProblemBase::checkUserObjectNameCollision(), BlockRestrictable::checkVariable(), DomainUserObject::checkVariable(), Coupleable::checkWritableVar(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBase::connectControllableParams(), ConstantPostprocessor::ConstantPostprocessor(), Coupleable::coupledName(), CommonOutputAction::create(), MultiApp::createApp(), MooseApp::createExecutors(), MeshGeneratorSystem::createMeshGeneratorOrder(), MooseApp::createRecoverablePerfGraph(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), DebugResidualAux::DebugResidualAux(), MaterialBase::declareADProperty(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), MeshInfo::declareHelper(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementDamper::ElementDamper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), RestartableDataReporter::execute(), MultiAppGeneralFieldTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), SideValueSampler::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), NEML2ModelExecutor::fillInputs(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FVFunctionIC::functionName(), FunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), BoundaryDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ManifoldSubdomainGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MooseMesh::getBoundaryString(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), MFEMProblem::getComplexGridFunction(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), UserObjectBase::getDependObjects(), FEProblemBase::getDistribution(), DistributionInterface::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), FEProblemBase::getExecutor(), MooseApp::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVAdvectedInterpolationMethod(), FEProblemBase::getFVFaceInterpolationMethod(), FEProblemBase::getFVInterpolationMethod(), AuxKernelTempl< ComputeValueType >::getGenericMaterialProperty(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), FEProblemBase::getKokkosFunction(), FEProblemBase::getKokkosUserObject(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), AuxKernelTempl< ComputeValueType >::getMaterialProperty(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOlder(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MFEMObject::getMatrixCoefficient(), MFEMObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MFEMProblem::getMFEMObject(), ActionWarehouse::getMooseAppName(), NEML2FEInterpolation::getMOOSEVariable(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MFEMExecutedObject::getRequestedItems(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMObject::getScalarCoefficient(), MFEMObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MFEMExecutedObject::getSuppliedItems(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMObject::getVectorCoefficient(), MFEMObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasDistribution(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), FEProblemBase::hasFVInterpolationMethod(), MeshInfo::hasItem(), MooseApp::hasMeshGenerator(), MFEMProblem::hasMFEMObject(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), AdvancedOutput::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), MeshInfo::initCombinedInfos(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), Console::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), NodalVariableValue::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppGeneralFieldFunctorTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< T >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< OutputType >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), Material::Material(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), NEML2ModelExecutor::meshChanged(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMScalarQuadratureFunction::MFEMScalarQuadratureFunction(), MFEMVectorQuadratureFunction::MFEMVectorQuadratureFunction(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< T >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NEML2PreKernel::NEML2PreKernel(), NodalDamper::NodalDamper(), MooseLinearVariableFV< OutputType >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), MeshGenerator::Comparator::operator()(), DOFMapOutput::output(), ProgressOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), Exodus::outputPostprocessors(), Nemesis::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), SolutionInvalidInterface::paramWarning(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseFunction::PiecewiseFunction(), MooseApp::possiblyLoadRestartableMetaData(), MFEMExecutedObject::postprocessorDependencyKey(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), FEProblemBase::setAuxKernelParamsAndLog(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), MooseMesh::setSubdomainName(), MooseMesh::setSubdomainName(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), TransientMultiApp::setupApp(), NEML2Action::setupOutputMappings(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), SumPostprocessor::SumPostprocessor(), MFEMPostprocessor::suppliedPostprocessorName(), MFEMVectorPostprocessor::suppliedVectorPostprocessorName(), NEML2FEInterpolation::syncWithMainThread(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< OutputType >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), MultiAppMFEMCopyTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), TransientMultiApp::TransientMultiApp(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVQpFluxBC::uOnGhost(), FVQpFluxBC::uOnUSub(), UserObjectBase::UserObjectBase(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), MeshInfo::validParams(), MFEMExecutedObject::variableDependencyKey(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), MFEMExecutedObject::vectorPostprocessorDependencyKey(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

◆ paramError()

template<typename... Args>
void MooseBase::paramError ( const std::string &  param,
Args...  args 
) const
inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 457 of file MooseBase.h.

458{
459 _pars.paramError(param, std::forward<Args>(args)...);
460}
InputParameters::paramError
void paramError(const std::string &param, Args... args) const
Emits a parameter error prefixed with the parameter location and object information if available.
Definition InputParameters.h:2511

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), CommonOutputAction::act(), SetupDebugAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayCoupledForce::ArrayCoupledForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayReactionNodalKernelTempl< is_ad >::ArrayReactionNodalKernelTempl(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelBase::AuxKernelBase(), BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundaryIntegralValueConstraint::BoundaryIntegralValueConstraint(), BoundaryLinearFVFluxIntegral::BoundaryLinearFVFluxIntegral(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMFESpaceHierarchy::buildHierarchy(), MFEMMesh::buildMesh(), MFEMGeometricMultigridSolver::BuildMultigrid(), TimeSequenceStepperBase::buildSequence(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), checkComponent(), Moose::Kokkos::ParsedObjectBase::checkDuplicateSymbols(), SamplerBase::checkForStandardFieldVariableType(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentJunction::ComponentJunction(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), MultiAppGeneralFieldTransfer::correctSolutionVectorValues(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ElementNormalAux::ElementNormalAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), AdvancedExtruderGenerator::generate(), BlockDeletionGenerator::generate(), BlockToMeshConverterGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryDeletionGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CoarsenBlockGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), SurfaceSubdomainsDelaunayRemesher::generate(), UniqueExtraIDMeshGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), BoundaryLayerUtils::generateOffsetPolyline(), GenericConstantStdVectorMaterialTempl< is_ad >::GenericConstantStdVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), AddPeriodicBCAction::getVariables(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MFEMTransient::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), SolutionIC::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), ElementSubdomainModifierBase::initialSetup(), MFEMScalarCoefficientPointValueSampler::initialSetup(), FullSolveMultiApp::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldKDTreeTransferBase::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatReactionTempl< is_ad >::MatReactionTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MeshInfo::MeshInfo(), MFEMComplexSumAux::MFEMComplexSumAux(), MFEMFunctorMaterial::MFEMFunctorMaterial(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMMultiAppTransfer::MFEMMultiAppTransfer(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMSumAux::MFEMSumAux(), MFEMVariable::MFEMVariable(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NEML2PreKernel::NEML2PreKernel(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), NumDOFs::NumDOFs(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), RankTwoTensorFromComponentProperties::RankTwoTensorFromComponentProperties(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusIIOrNemesis(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), CylinderComponent::setupComponent(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupInputMappings(), MultiSystemSolveObject::setupMultiSystemFixedPointRelaxationFactors(), NEML2Action::setupParameterDerivativeMappings(), NEML2Action::setupParameterMappings(), SetupQuadratureAction::SetupQuadratureAction(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), CylinderComponent::translation(), MeshTriangulationUtils::triangulateWithDelaunay(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), UserObjectBase::UserObjectBase(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), MFEMProblem::validateVariableNumericType(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ parameterConsistent()

bool InputParametersChecksUtils< BatchMeshGeneratorAction >::parameterConsistent ( const InputParameters &  other_param,
const std::string &  param_name 
) const
protectedinherited

Return whether two parameters are consistent.

Parameters
other_paramInputParameters object from another object to check the 'param_name' parameter in
param_namethe name of the parameter to check for consistency

Definition at line 126 of file InputParametersChecksUtils.h.

462{
463 assertParamDefined<T>(param_name);
464 mooseAssert(other_param.have_parameter<T>(param_name),
465 "This should have been a parameter from the parameters being compared");
466 bool consistent = true;
467 if (forwardParameters().isParamValid(param_name) && other_param.isParamValid(param_name))
468 {
469 if constexpr (std::is_same_v<MooseEnum, T>)
470 {
471 if (!forwardGetParam<T>(param_name).compareCurrent(other_param.get<T>(param_name)))
472 consistent = false;
473 }
474 else if (forwardGetParam<T>(param_name) != other_param.get<T>(param_name))
475 consistent = false;
476 }
477 return consistent;
478}
InputParameters::have_parameter
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
Definition InputParameters.h:2402

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const
inlineinherited

Get the parameters of the object.

Returns
The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

Referenced by AddActionComponentAction::act(), CommonOutputAction::act(), CSGOnlyAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), SplitMeshAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxKernel(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), MFEMProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), FEProblemBase::addIndicator(), MFEMProblem::addIndicator(), FEProblemBase::addInitialCondition(), MFEMProblem::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), FEProblemBase::addKernel(), MFEMProblem::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), MFEMProblem::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), MFEMProblem::addQuadratureFunction(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), MFEMProblem::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), MFEMEigenproblem::addVariable(), MFEMProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), MFEMProblem::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), MooseMeshUtils::copyIntoMesh(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), ElementSubdomainModifierBase::extrapolatePolynomial(), FEProblem::FEProblem(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainGeneratorBase::generate(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), Moose::PeriodicBCHelper::getParams(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), AuxKernelBase::getVariableHelper(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), MeshGeneratorSystem::hasDataDrivenAllowed(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseObject::isKokkosObject(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< T >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setInputParametersFEProblem(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

◆ paramInfo()

template<typename... Args>
void MooseBase::paramInfo ( const std::string &  param,
Args...  args 
) const
inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 471 of file MooseBase.h.

472{
473 mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
474}
InputParameters::paramMessage
std::string paramMessage(const std::string &param, Args... args) const
Definition InputParameters.h:2502

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

◆ paramWarning() [1/2]

template<typename... Args>
void MooseBase::paramWarning ( const std::string &  param,
Args...  args 
) const
inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 464 of file MooseBase.h.

465{
466 mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
467}

◆ paramWarning() [2/2]

template<typename... Args>
void SolutionInvalidInterface::paramWarning ( const std::string &  param,
Args...  args 
) const
inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

95 {
96 _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
97 flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
98 param + "'");
99 }

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )
inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

87{
88 return _pg_moose_app.perfGraph();
89}
MooseApp::perfGraph
PerfGraph & perfGraph()
Get the PerfGraph for this app.
Definition MooseApp.h:179
PerfGraphInterface::_pg_moose_app
MooseApp & _pg_moose_app
The MooseApp that owns the PerfGraph.
Definition PerfGraphInterface.h:135

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

◆ queryParam()

template<typename T >
const T * MooseBase::queryParam ( const std::string &  name) const
inherited

Query a parameter for the object.

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

Parameters
nameThe name of the parameter
Returns
A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

414{
415 return _pars.queryParam<T>(name);
416}
InputParameters::queryParam
const T * queryParam(const std::string &name) const
Query a parameter.
Definition InputParameters.h:2311

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

◆ registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal ( const std::string &  message,
const bool  warning 
) const
protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

57{
58 return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
59 _si_moose_base.type(), message, warning);
60}
moose::internal::SolutionInvalidityRegistry::registerInvalidity
InvalidSolutionID registerInvalidity(const std::string &object_type, const std::string &message, const bool warning)
Call to register an invalid calculation.
Definition SolutionInvalidityRegistry.C:33

◆ registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name,
const unsigned int  level 
) const
protectedinherited

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
Returns
The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

63{
64 const auto timed_section_name = timedSectionName(section_name);
65 if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
66 return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
67 else
68 return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
69}
PerfGraphInterface::timedSectionName
std::string timedSectionName(const std::string &section_name) const
Definition PerfGraphInterface.C:55
moose::internal::PerfGraphRegistry::sectionID
PerfID sectionID(const std::string &section_name) const
Given a name return the PerfID @section_name The name of the section.
Definition PerfGraphRegistry.h:111
moose::internal::PerfGraphRegistry::registerSection
PerfID registerSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
Definition PerfGraphRegistry.C:34
moose::internal::getPerfGraphRegistry
PerfGraphRegistry & getPerfGraphRegistry()
Get the global PerfGraphRegistry singleton.
Definition PerfGraphRegistry.C:20

◆ registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name,
const unsigned int  level,
const std::string &  live_message,
const bool  print_dots = true 
) const
protectedinherited

Call to register a named section for timing.

Parameters
section_nameThe name of the code section to be timed
levelThe importance of the timer - lower is more important (0 will always come out)
live_messageThe message to be printed to the screen during execution
print_dotsWhether or not progress dots should be printed for this section
Returns
The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

76{
77 const auto timed_section_name = timedSectionName(section_name);
78 if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
79 return moose::internal::getPerfGraphRegistry().registerSection(
80 timedSectionName(section_name), level, live_message, print_dots);
81 else
82 return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
83}

◆ setScalarParams()

void BatchMeshGeneratorAction::setScalarParams ( InputParameters &  params,
const std::string &  param_name,
const ParameterType &  param_type,
const std::string &  param_value 
) const
protected

Set the scalar input parameters for a unit mesh generator.

Parameters
paramsInputParameters object to set the parameters
param_nameName of the parameter to set
param_typeType of the parameter to set
param_valueValue of the parameter to set in string format

Definition at line 617 of file BatchMeshGeneratorAction.C.

621{
622 switch (param_type)
623 {
624 case (ParameterType::REAL):
625 params.set<Real>(param_name) = MooseUtils::convert<Real>(param_value);
626 break;
627 case (ParameterType::SHORT):
628 params.set<short>(param_name) = MooseUtils::convert<short>(param_value);
629 break;
630 case (ParameterType::USHORT):
631 params.set<unsigned short>(param_name) = MooseUtils::convert<unsigned short>(param_value);
632 break;
633 case (ParameterType::INT):
634 params.set<int>(param_name) = MooseUtils::convert<int>(param_value);
635 break;
636 case (ParameterType::UINT):
637 params.set<unsigned int>(param_name) = MooseUtils::convert<unsigned int>(param_value);
638 break;
639 case (ParameterType::LONG):
640 params.set<long>(param_name) = MooseUtils::convert<long>(param_value);
641 break;
642 case (ParameterType::ULONG):
643 params.set<unsigned long>(param_name) = MooseUtils::convert<unsigned long>(param_value);
644 break;
645 case (ParameterType::LONGLONG):
646 params.set<long long>(param_name) = MooseUtils::convert<long long>(param_value);
647 break;
648 case (ParameterType::ULONGLONG):
649 params.set<unsigned long long>(param_name) =
650 MooseUtils::convert<unsigned long long>(param_value);
651 break;
652 case (ParameterType::DOFIDTYPE):
653 params.set<dof_id_type>(param_name) = MooseUtils::convert<dof_id_type>(param_value);
654 break;
655 case (ParameterType::BDRYIDTYPE):
656 params.set<boundary_id_type>(param_name) = MooseUtils::convert<boundary_id_type>(param_value);
657 break;
658 case (ParameterType::SDIDTYPE):
659 params.set<subdomain_id_type>(param_name) =
660 MooseUtils::convert<subdomain_id_type>(param_value);
661 break;
662 case (ParameterType::ENUM):
663 params.set<MooseEnum>(param_name) = param_value;
664 break;
665 case (ParameterType::STRING):
666 params.set<std::string>(param_name) = param_value;
667 break;
668 case (ParameterType::SDNAME):
669 params.set<SubdomainName>(param_name) = param_value;
670 break;
671 case (ParameterType::BDRYNAME):
672 params.set<BoundaryName>(param_name) = param_value;
673 break;
674 case (ParameterType::MGNAME):
675 params.set<MeshGeneratorName>(param_name) = param_value;
676 break;
677 case (ParameterType::MFNAME):
678 params.set<MeshFileName>(param_name) = param_value;
679 break;
680 case (ParameterType::BOOL):
681 hit::toBool(param_value, &params.set<bool>(param_name));
682 break;
683 case (ParameterType::REALVECTORVALUE):
684 params.set<RealVectorValue>(param_name) =
685 convertStringToCompoundRealScalar<RealVectorValue>(param_value);
686 break;
687 case (ParameterType::POINT):
688 params.set<Point>(param_name) = convertStringToCompoundRealScalar<Point>(param_value);
689 break;
690 default:
691 mooseAssert(false,
692 "impossible situation."); // as we use MultiMooseEnum to ensure the type is valid
693 }
694}
libMesh::boundary_id_type
int8_t boundary_id_type
libMesh::subdomain_id_type
TestClass subdomain_id_type
libMesh::RealVectorValue
VectorValue< Real > RealVectorValue
Definition SubProblem.h:34
libMesh::dof_id_type
uint8_t dof_id_type

Referenced by addMeshGenerators().

◆ setVectorParams()

void BatchMeshGeneratorAction::setVectorParams ( InputParameters &  params,
const std::string &  param_name,
const ParameterType &  param_type,
const std::vector< std::string > &  param_value 
) const
protected

Set the vector input parameters for a unit mesh generator.

Parameters
paramsInputParameters object to set the parameters
param_nameName of the parameter to set
param_typeType of the parameter to set
param_valueValue of the parameter to set in string format

Definition at line 697 of file BatchMeshGeneratorAction.C.

701{
702 switch (param_type)
703 {
704 case (ParameterType::REAL):
705 convertAndSetNumericVector<Real>(params, param_name, param_value);
706 break;
707 case (ParameterType::SHORT):
708 convertAndSetNumericVector<short>(params, param_name, param_value);
709 break;
710 case (ParameterType::USHORT):
711 convertAndSetNumericVector<unsigned short>(params, param_name, param_value);
712 break;
713 case (ParameterType::INT):
714 convertAndSetNumericVector<int>(params, param_name, param_value);
715 break;
716 case (ParameterType::UINT):
717 convertAndSetNumericVector<unsigned int>(params, param_name, param_value);
718 break;
719 case (ParameterType::LONG):
720 convertAndSetNumericVector<long>(params, param_name, param_value);
721 break;
722 case (ParameterType::ULONG):
723 convertAndSetNumericVector<unsigned long>(params, param_name, param_value);
724 break;
725 case (ParameterType::LONGLONG):
726 convertAndSetNumericVector<long long>(params, param_name, param_value);
727 break;
728 case (ParameterType::ULONGLONG):
729 convertAndSetNumericVector<unsigned long long>(params, param_name, param_value);
730 break;
731 case (ParameterType::DOFIDTYPE):
732 convertAndSetNumericVector<dof_id_type>(params, param_name, param_value);
733 break;
734 case (ParameterType::BDRYIDTYPE):
735 convertAndSetNumericVector<boundary_id_type>(params, param_name, param_value);
736 break;
737 case (ParameterType::SDIDTYPE):
738 convertAndSetNumericVector<subdomain_id_type>(params, param_name, param_value);
739 break;
740 case (ParameterType::ENUM):
741 params.set<MultiMooseEnum>(param_name) = param_value;
742 break;
743 case (ParameterType::STRING):
744 params.set<std::vector<std::string>>(param_name) = param_value;
745 break;
746 case (ParameterType::SDNAME):
747 convertAndSetStringLikeVector<SubdomainName>(params, param_name, param_value);
748 break;
749 case (ParameterType::BDRYNAME):
750 convertAndSetStringLikeVector<BoundaryName>(params, param_name, param_value);
751 break;
752 case (ParameterType::MGNAME):
753 convertAndSetStringLikeVector<MeshGeneratorName>(params, param_name, param_value);
754 break;
755 case (ParameterType::MFNAME):
756 convertAndSetStringLikeVector<MeshFileName>(params, param_name, param_value);
757 break;
758 case (ParameterType::BOOL):
759 {
760 std::vector<bool> values(param_value.size());
761 std::transform(param_value.begin(),
762 param_value.end(),
763 values.begin(),
764 [](const std::string & val)
765 {
766 bool tmp;
767 hit::toBool(val, &tmp);
768 return tmp;
769 });
770 params.set<std::vector<bool>>(param_name) = values;
771 break;
772 }
773 case (ParameterType::REALVECTORVALUE):
774 convertAndSetCompoundRealScalarVector<RealVectorValue>(params, param_name, param_value);
775 break;
776 case (ParameterType::POINT):
777 convertAndSetCompoundRealScalarVector<Point>(params, param_name, param_value);
778 break;
779 default:
780 mooseAssert(false,
781 "impossible situation."); // as we use MultiMooseEnum to ensure the type is valid
782 }
783}

Referenced by addMeshGenerators().

◆ specificTaskName()

const std::string & Action::specificTaskName ( ) const
inlineinherited

Definition at line 110 of file Action.h.

110{ return _specific_task_name; }
Action::_specific_task_name
std::string _specific_task_name
This member will only be populated if this Action instance is only designed to handle one task.
Definition Action.h:159

◆ timedAct()

void Action::timedAct ( )
inherited

The method called externally that causes the action to act()

Definition at line 76 of file Action.C.

77{
78 TIME_SECTION(_act_timer);
79
80 const auto parallel_verify = [libmesh_dbg_var(this)](const bool libmesh_dbg_var(before))
81 {
82#ifndef NDEBUG
83 const std::string value = this->typeAndName() + "_" + _current_task;
84 if (!comm().verify(value.size()) || !comm().verify(value))
85 mooseError("Parallel inconsistency found ",
86 before ? "before" : "after",
87 " executing task ",
88 _current_task);
89#endif
90 };
91
92 parallel_verify(true);
93
94 act();
95
96 parallel_verify(false);
97}
Action::act
virtual void act()=0
Method to add objects to the simulation or perform other setup tasks.
Action::_act_timer
PerfID _act_timer
Timers.
Definition Action.h:181
MooseBase::typeAndName
std::string typeAndName() const
Get the class's combined type and name; useful in error handling.
Definition MooseBase.C:57
libMesh::ParallelObject::comm
const Parallel::Communicator & comm() const

Referenced by ActionWarehouse::executeActionsWithAction().

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name) const
protectedinherited
Returns
The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

56{
57 return _prefix.empty() ? "" : (_prefix + "::") + section_name;
58}
PerfGraphInterface::_prefix
const std::string _prefix
A prefix to use for all sections.
Definition PerfGraphInterface.h:138

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

◆ type()

const std::string & MooseBase::type ( ) const
inlineinherited

Get the type of this class.

Returns
the name of the type of this class

Definition at line 93 of file MooseBase.h.

94 {
95 mooseAssert(_type.size(), "Empty type");
96 return _type;
97 }
MooseBase::_type
const std::string & _type
The type of this class.
Definition MooseBase.h:378

Referenced by CreateProblemDefaultAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), SetupDebugAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addConvergence(), FEProblemBase::addDistribution(), DistributedRectilinearMeshGenerator::addElement(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addObject(), DistributedRectilinearMeshGenerator::addPoint(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addQuadratureFunction(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addVectorPostprocessor(), SubProblem::addVectorTag(), DisplacedProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelBase::AuxKernelBase(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), FEProblemBase::checkUserObjectNameCollision(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), MeshInfo::CombinedInfos< ElemInfoMap, ElemInfoItems >::CombinedInfos(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ADDGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ADDGKernel::computeElemNeighResidual(), ArrayDGLowerDKernel::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpJacobian(), HFEMDirichletBC::computeLowerDQpJacobian(), ArrayHFEMDiffusion::computeLowerDQpJacobian(), HFEMDiffusion::computeLowerDQpJacobian(), ArrayLowerDIntegratedBC::computeLowerDQpOffDiagJacobian(), ArrayDGLowerDKernel::computeLowerDQpOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpOffDiagJacobian(), HFEMDirichletBC::computeLowerDQpOffDiagJacobian(), FEProblemBase::computeMultiAppsDT(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ADDGKernel::computeOffDiagElemNeighJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGConvection::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), DGDiffusion::computeQpJacobian(), InterfaceDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), HFEMTrialJump::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), DGConvection::computeQpResidual(), ADDGAdvection::computeQpResidual(), ADDGDiffusion::computeQpResidual(), DGDiffusion::computeQpResidual(), HFEMDiffusion::computeQpResidual(), HFEMTestJump::computeQpResidual(), HFEMTrialJump::computeQpResidual(), ADMatInterfaceReaction::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), InterfaceReaction::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), ArrayHFEMDiffusion::computeQpResidual(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::createQRules(), DisplacedProblem::createQRules(), MooseApp::createRecoverablePerfGraph(), MeshGenerator::declareMeshProperty(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::execTransfers(), SteadyBase::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), Boundary2DDelaunayGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), MooseServer::getSyntaxMetadata(), FEProblemBase::getTransfers(), FEProblemBase::getUOQuery(), SubProblem::getVectorTags(), DisplacedProblem::getVectorTags(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), NEML2Action::inferMOOSEIOType(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), LinearFVAdvection::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVDiffusion::initialSetup(), MultiAppConservativeTransfer::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MFEMProblem::mesh(), MooseObject::MooseObject(), SubProblem::numVectorTags(), DisplacedProblem::numVectorTags(), AdvancedOutput::output(), Console::output(), ConsoleUtils::outputExecutionInformation(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), MooseMesh::prepare(), ProjectedStatefulMaterialStorageAction::processProperty(), MooseApp::recursivelyCreateExecutors(), SolutionInvalidInterface::registerInvalidSolutionInternal(), FEProblemBase::restoreMultiApps(), MeshRepairGenerator::separateSubdomainsByElementType(), FEProblemBase::setCoupling(), MooseApp::setupOptions(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), Reporter::store(), MooseBase::typeAndName(), AuxScalarKernel::uOld(), ScalarKernelBase::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const
inherited

Get the class's combined type and name; useful in error handling.

Returns
The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

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

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

◆ uniqueActionName()

MooseObjectName Action::uniqueActionName ( ) const
inlineinherited

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

Definition at line 108 of file Action.h.

108{ return uniqueName(); }

Referenced by NEML2Action::NEML2Action().

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const
inherited
Returns
The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

70{
71 if (!_pars.have_parameter<std::string>(unique_name_param))
72 mooseError("uniqueName(): Object does not have a unique name");
73 return MooseObjectName(_pars.get<std::string>(unique_name_param));
74}
MooseBase::unique_name_param
static const std::string unique_name_param
The name of the parameter that contains the unique object name.
Definition MooseBase.h:57
MooseObjectName
A class for storing the names of MooseObject by tag and object name.
Definition MooseObjectName.h:41

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

◆ uniqueParameterName()

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

Definition at line 63 of file MooseBase.C.

64{
65 return MooseObjectParameterName(getBase(), name(), parameter_name);
66}
MooseBase::getBase
const std::string & getBase() const
Definition MooseBase.h:147

◆ validParams()

InputParameters BatchMeshGeneratorAction::validParams ( )
static

Definition at line 25 of file BatchMeshGeneratorAction.C.

26{
27 InputParameters params = Action::validParams();
28
29 params.set<std::string>("type") = "BatchMeshGeneratorAction";
30
31 params.addClassDescription("Batch generate meshes using actions.");
32 params.addRequiredParam<std::string>("mesh_generator_type",
33 "Type of the mesh generator to be batch generated.");
34 params.addRequiredParam<std::string>("mesh_name_prefix",
35 "Prefix name of the meshes to be batch generated.");
36
37 params.addParam<std::vector<std::string>>("batch_scalar_input_param_names",
38 std::vector<std::string>(),
39 "Names of the scalar input parameters to be altered.");
40 MultiMooseEnum default_types(
41 "BOOL REAL SHORT USHORT INT UINT LONG ULONG LONGLONG ULONGLONG DOFIDTYPE BDRYIDTYPE SDIDTYPE "
42 "STRING SDNAME BDRYNAME MGNAME MFNAME ENUM REALVECTORVALUE POINT",
43 "");
44 params.addParam<MultiMooseEnum>(
45 "batch_scalar_input_param_types",
46 default_types,
47 "Types of the scalar input parameters to be altered in each generator of the batch.");
48 params.addParam<std::vector<std::vector<std::string>>>(
49 "batch_scalar_input_param_values",
50 {},
51 "Values of the scalar input parameters to be assigned.");
52
53 params.addParam<std::vector<std::string>>("batch_vector_input_param_names",
54 std::vector<std::string>(),
55 "Name of the vector input parameters to be altered.");
56 params.addParam<MultiMooseEnum>("batch_vector_input_param_types",
57 default_types,
58 "Type of the vector input parameters to be altered.");
59 params.addParam<std::vector<std::vector<std::vector<std::string>>>>(
60 "batch_vector_input_param_values",
61 {},
62 "Values of the vector input parameters to be assigned.");
63
64 MooseEnum multi_batch_params_method("corresponding cartesian_product", "cartesian_product");
65 params.addParam<MooseEnum>("multi_batch_params_method",
66 multi_batch_params_method,
67 "Method to generate multiple batch parameters.Options: " +
68 multi_batch_params_method.getRawNames());
69
70 params.addParam<std::vector<std::string>>(
71 "fixed_scalar_input_param_names", {}, "Names of the input parameters to be fixed.");
72 params.addParam<MultiMooseEnum>("fixed_scalar_input_param_types",
73 default_types,
74 "Types of the input parameters to be fixed.");
75 params.addParam<std::vector<std::string>>(
76 "fixed_scalar_input_param_values", {}, "Values of the input parameters to be fixed.");
77 params.addParam<std::vector<std::string>>(
78 "fixed_vector_input_param_names", {}, "Names of the input vector parameters to be fixed.");
79 params.addParam<MultiMooseEnum>("fixed_vector_input_param_types",
80 default_types,
81 "Types of the input vector parameters to be fixed.");
82 params.addParam<std::vector<std::vector<std::string>>>(
83 "fixed_vector_input_param_values", {}, "Values of the input vector parameters to be fixed.");
84 params.addParam<bool>("use_decomposed_index",
85 false,
86 "Whether to use the decomposed index for the mesh name (only effective for "
87 "the cartesian_product method).");
88
89 params.addParamNamesToGroup("batch_scalar_input_param_names batch_scalar_input_param_types "
90 "batch_scalar_input_param_values "
91 "batch_vector_input_param_names batch_vector_input_param_types "
92 "batch_vector_input_param_values",
93 "Batch Input");
94 params.addParamNamesToGroup("fixed_scalar_input_param_names fixed_scalar_input_param_types "
95 "fixed_scalar_input_param_values "
96 "fixed_vector_input_param_names fixed_vector_input_param_types "
97 "fixed_vector_input_param_values",
98 "Fixed Input");
99
100 return params;
101}
Action::validParams
static InputParameters validParams()
Definition Action.C:26
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system.
Definition InputParameters.h:68
InputParameters::addParamNamesToGroup
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...
Definition InputParameters.C:1027
InputParameters::addParam
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object.
Definition InputParameters.h:1832
InputParameters::addRequiredParam
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 extr...
Definition InputParameters.h:1806
InputParameters::addClassDescription
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.
Definition InputParameters.C:81
MooseEnumBase::getRawNames
std::string getRawNames() const
Method for returning the raw name strings for this instance.
Definition MooseEnumBase.C:159

◆ warnInconsistent()

void InputParametersChecksUtils< BatchMeshGeneratorAction >::warnInconsistent ( const InputParameters &  parameters,
const std::string &  param_name 
) const
protectedinherited

Emits a warning if two parameters are not equal to each other.

Parameters
other_paramInputParameters object from another object to check the 'param_name' parameter in
param_namethe name of the parameter to check for consistency

Definition at line 132 of file InputParametersChecksUtils.h.

551{
552 const bool consistent = parameterConsistent<T>(other_param, param_name);
553 if (!consistent)
554 forwardMooseWarning("Parameter " + param_name + " is inconsistent between Physics \"" +
555 forwardName() + "\" of type \"" + forwardType() +
556 "\" and the parameter set for \"" + other_param.getObjectName() +
557 "\" of type \"" + other_param.getObjectType() + "\"");
558}
InputParametersChecksUtils< BatchMeshGeneratorAction >::forwardMooseWarning
void forwardMooseWarning(Args &&... args) const
Forwards warning to the class using this utility to get better error messages.
Definition InputParametersChecksUtils.h:183

Member Data Documentation

◆ _act_timer

PerfID Action::_act_timer
protectedinherited

Timers.

Definition at line 181 of file Action.h.

Referenced by Action::timedAct().

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory
protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

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

◆ _all_tasks

std::set<std::string> Action::_all_tasks
protectedinherited

A list of all the tasks that this Action will satisfy.

Note: That this is not populated at construction time. However, all tasks will be added prior to act().

Definition at line 166 of file Action.h.

Referenced by Action::appendTask(), and Action::getAllTasks().

◆ _app

MooseApp& MooseBase::_app
protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by ElementIDOutputAction::act(), AdaptivityAction::act(), AddExecutorAction::act(), AddMeshGeneratorAction::act(), AddPeriodicBCAction::act(), AddRelationshipManager::act(), AddTimeStepperAction::act(), AutoCheckpointAction::act(), CheckIntegrityAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CopyNodalVarsAction::act(), CouplingFunctorCheckAction::act(), CreateAddedMeshGenerators::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CSGOnlyAction::act(), DeclareLateReportersAction::act(), DisplayGhostingAction::act(), ExecuteMeshGenerators::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), ReadExecutorParamsAction::act(), ResolveOptionalMaterialPropertiesAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupPredictorAction::act(), SetupRecoverFileBaseAction::act(), SetupTimeStepperAction::act(), SplitMeshAction::act(), Action::Action(), addMeshGenerators(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), BatchMeshGeneratorAction(), CheckOutputAction::checkConsoleOutput(), CheckOutputAction::checkMaterialOutput(), CheckOutputAction::checkPerfLogOutput(), CheckOutputAction::checkVariableOutput(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), NEML2Action::NEML2Action(), PhysicsBase::prepareCopyVariablesFromMesh(), NEML2Action::printSummary(), PhysicsBase::reportPotentiallyMissedParameters(), MeshGeneratorComponent::setupComponent(), SetupMeshAction::setupMesh(), and PhysicsBase::shouldCreateIC().

◆ _awh

ActionWarehouse& Action::_awh
protectedinherited

Reference to ActionWarehouse where we store object build by actions.

Definition at line 169 of file Action.h.

Referenced by AddActionComponentAction::act(), AddRelationshipManager::act(), CheckIntegrityAction::act(), CombineComponentsMeshes::act(), CreateExecutionerAction::act(), CreateMeshSetupActionsForComponents::act(), CreateProblemDefaultAction::act(), ReadExecutorParamsAction::act(), SetupDampersAction::act(), SetupMeshAction::act(), SetupTimeStepperAction::act(), AddActionComponentAction::AddActionComponentAction(), ComponentJunction::addMeshGenerators(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), PhysicsBase::getActionComponent(), NEML2Action::getCommonAction(), PhysicsBase::getCoupledPhysics(), PhysicsBase::getCoupledPhysics(), ActionComponent::getProblem(), CommonOutputAction::hasConsole(), ComponentPhysicsInterface::physicsExists(), CreateExecutionerAction::setupAutoPreconditioning(), ReadExecutorParamsAction::setupAutoPreconditioning(), CylinderComponent::setupComponent(), and SetupDebugAction::SetupDebugAction().

◆ _batch_scalar_input_param_names

const std::vector<std::string> BatchMeshGeneratorAction::_batch_scalar_input_param_names
protected

Names of the scalar input parameters to vary in the batch generation.

Definition at line 68 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _batch_scalar_input_param_types

const std::vector<ParameterType> BatchMeshGeneratorAction::_batch_scalar_input_param_types
protected

Types of the scalar input parameters to vary in the batch generation.

Definition at line 70 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _batch_scalar_input_param_values

std::vector<std::vector<std::string> > BatchMeshGeneratorAction::_batch_scalar_input_param_values
protected

Values of the scalar input parameters to vary in the batch generation.

Definition at line 72 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _batch_vector_input_param_names

const std::vector<std::string> BatchMeshGeneratorAction::_batch_vector_input_param_names
protected

Names of the vector input parameters to vary in the batch generation.

Definition at line 74 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _batch_vector_input_param_types

const std::vector<ParameterType> BatchMeshGeneratorAction::_batch_vector_input_param_types
protected

Types of the vector input parameters to vary in the batch generation.

Definition at line 76 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _batch_vector_input_param_values

std::vector<std::vector<std::vector<std::string> > > BatchMeshGeneratorAction::_batch_vector_input_param_values
protected

Values of the vector input parameters to vary in the batch generation.

Definition at line 78 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console
inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

◆ _current_task

const std::string& Action::_current_task
protectedinherited

The current action (even though we have separate instances for each action)

Definition at line 172 of file Action.h.

Referenced by ElementIDOutputAction::act(), AdaptivityAction::act(), AddActionComponentAction::act(), AddDefaultConvergenceAction::act(), AddDGKernelAction::act(), AddFVBCAction::act(), AddFVInterfaceKernelAction::act(), AddFVKernelAction::act(), AddInterfaceKernelAction::act(), AddKernelAction::act(), AddNodalNormalsAction::act(), AddOutputAction::act(), AddPeriodicBCAction::act(), AddRelationshipManager::act(), AddScalarKernelAction::act(), AddTimeStepperAction::act(), CheckFVBCAction::act(), CheckIntegrityAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), CopyNodalVarsAction::act(), CreateDisplacedProblemAction::act(), CreateMeshSetupActionsForComponents::act(), CreateProblemDefaultAction::act(), CSGOnlyAction::act(), DisplayGhostingAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), SetAdaptivityOptionsAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupRecoverFileBaseAction::act(), SetupTimeIntegratorAction::act(), ActionComponent::act(), act(), PhysicsBase::act(), PhysicsComponentInterface::actOnAdditionalTasks(), ProjectedStatefulMaterialStorageAction::processProperty(), and Action::timedAct().

◆ _customer_class

const BatchMeshGeneratorAction * const InputParametersChecksUtils< BatchMeshGeneratorAction >::_customer_class
privateinherited

Definition at line 200 of file InputParametersChecksUtils.h.

◆ _displaced_mesh

std::shared_ptr<MooseMesh>& Action::_displaced_mesh
protectedinherited

Definition at line 175 of file Action.h.

Referenced by CreateDisplacedProblemAction::act(), SetupMeshAction::act(), and SetupMeshCompleteAction::act().

◆ _factory

Factory& ParallelParamObject::_factory
protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

◆ _fixed_scalar_input_param_names

const std::vector<std::string> BatchMeshGeneratorAction::_fixed_scalar_input_param_names
protected

Names of the vector input parameters to keep fixed in the batch generation.

Definition at line 82 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _fixed_scalar_input_param_types

const std::vector<ParameterType> BatchMeshGeneratorAction::_fixed_scalar_input_param_types
protected

Types of the vector input parameters to keep fixed in the batch generation.

Definition at line 84 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _fixed_scalar_input_param_values

std::vector<std::string> BatchMeshGeneratorAction::_fixed_scalar_input_param_values
protected

Values of the vector input parameters to keep fixed in the batch generation.

Definition at line 86 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _fixed_vector_input_param_names

const std::vector<std::string> BatchMeshGeneratorAction::_fixed_vector_input_param_names
protected

Names of the vector input parameters to keep fixed in the batch generation.

Definition at line 88 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _fixed_vector_input_param_types

const std::vector<ParameterType> BatchMeshGeneratorAction::_fixed_vector_input_param_types
protected

Types of the vector input parameters to keep fixed in the batch generation.

Definition at line 90 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _fixed_vector_input_param_values

std::vector<std::vector<std::string> > BatchMeshGeneratorAction::_fixed_vector_input_param_values
protected

Values of the vector input parameters to keep fixed in the batch generation.

Definition at line 92 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _mesh

std::shared_ptr<MooseMesh>& Action::_mesh
protectedinherited

Definition at line 174 of file Action.h.

Referenced by ElementIDOutputAction::act(), AdaptivityAction::act(), AddMeshGeneratorAction::act(), AddPeriodicBCAction::act(), CreateDisplacedProblemAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CSGOnlyAction::act(), ExecuteMeshGenerators::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), PhysicsBase::addBlocks(), PhysicsBase::addBlocksById(), AddActionComponentAction::addRelationshipManagers(), PhysicsBase::allMeshBlocks(), PhysicsBase::dimension(), PhysicsBase::getSubdomainIDs(), PhysicsBase::getSubdomainNamesAndIDs(), PhysicsBase::initializePhysics(), MeshGeneratorComponent::setupComponent(), and PhysicsBase::shouldCreateTimeDerivative().

◆ _mesh_generator_type

const std::string BatchMeshGeneratorAction::_mesh_generator_type
protected

Type (object name) of the mesh generator to use for batch generation.

Definition at line 64 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _mesh_name_prefix

const std::string BatchMeshGeneratorAction::_mesh_name_prefix
protected

Prefix to use for naming the batch generated meshes.

Definition at line 66 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators().

◆ _meta_data_app

MooseApp& MeshMetaDataInterface::_meta_data_app
privateinherited

Reference to the application.

Definition at line 122 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::getMeshPropertyInternal(), and MeshMetaDataInterface::hasMeshProperty().

◆ _meta_data_object

const MooseObject* const MeshMetaDataInterface::_meta_data_object
privateinherited

The MooseObject (if any); used for better error handling.

Definition at line 125 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::mooseErrorInternal().

◆ _multi_batch_params_method

const MultiBatchParamsMethod BatchMeshGeneratorAction::_multi_batch_params_method
protected

Method to use for generating the batch parameters.

Definition at line 80 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ _name

const std::string& MooseBase::_name
protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

Referenced by AddFieldSplitAction::act(), AddBCAction::act(), AddConstraintAction::act(), AddControlAction::act(), AddConvergenceAction::act(), AddCorrectorAction::act(), AddDamperAction::act(), AddDGKernelAction::act(), AddDiracKernelAction::act(), AddDistributionAction::act(), AddFunctionAction::act(), AddFunctorMaterialAction::act(), AddFVBCAction::act(), AddFVInitialConditionAction::act(), AddFVInterfaceKernelAction::act(), AddFVInterpolationMethodAction::act(), AddFVKernelAction::act(), AddHDGKernelAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddInterfaceKernelAction::act(), AddKernelAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddMarkerAction::act(), AddMaterialAction::act(), AddMeshDivisionAction::act(), AddMeshGeneratorAction::act(), AddMeshModifiersAction::act(), AddMultiAppAction::act(), AddNodalKernelAction::act(), AddOutputAction::act(), AddPositionsAction::act(), AddPostprocessorAction::act(), AddReporterAction::act(), AddSamplerAction::act(), AddScalarKernelAction::act(), AddTimesAction::act(), AddTimeStepperAction::act(), AddTransferAction::act(), AddUserObjectAction::act(), AddVectorPostprocessorAction::act(), PartitionerAction::act(), ReadExecutorParamsAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), AddMFEMFESpaceAction::act(), AddMFEMFESpaceHierarchyAction::act(), AddMFEMQuadratureFunctionAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), MultiApp::fillPositions(), CentroidMultiApp::fillPositions(), QuadraturePointMultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), MooseBase::name(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and AddVariableAction::varName().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent
privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

◆ _pars

const InputParameters& MooseBase::_pars
protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app
protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _prefix

const std::string PerfGraphInterface::_prefix
protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _problem

std::shared_ptr<FEProblemBase>& Action::_problem
protectedinherited

Convenience reference to a problem this action works on.

Definition at line 178 of file Action.h.

Referenced by AddFieldSplitAction::act(), ElementIDOutputAction::act(), AdaptivityAction::act(), AddAuxKernelAction::act(), AddBCAction::act(), AddBoundsVectorsAction::act(), AddConstraintAction::act(), AddControlAction::act(), AddConvergenceAction::act(), AddCorrectorAction::act(), AddDamperAction::act(), AddDGKernelAction::act(), AddDiracKernelAction::act(), AddDistributionAction::act(), AddExternalAuxVariableAction::act(), AddFunctionAction::act(), AddFunctorMaterialAction::act(), AddFVBCAction::act(), AddFVICAction::act(), AddFVInitialConditionAction::act(), AddFVInterfaceKernelAction::act(), AddFVInterpolationMethodAction::act(), AddFVKernelAction::act(), AddHDGKernelAction::act(), AddICAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddInterfaceKernelAction::act(), AddKernelAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddMarkerAction::act(), AddMaterialAction::act(), AddMeshDivisionAction::act(), AddMeshModifiersAction::act(), AddMultiAppAction::act(), AddNodalKernelAction::act(), AddNodalNormalsAction::act(), AddOutputAction::act(), AddPeriodicBCAction::act(), AddPositionsAction::act(), AddPostprocessorAction::act(), AddReporterAction::act(), AddSamplerAction::act(), AddScalarKernelAction::act(), AddTaggedMatricesAction::act(), AddTimesAction::act(), AddTimeStepperAction::act(), AddTransferAction::act(), AddUserObjectAction::act(), AddVectorPostprocessorAction::act(), AutoCheckpointAction::act(), ChainControlSetupAction::act(), CheckFVBCAction::act(), CheckIntegrityAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CopyNodalVarsAction::act(), CouplingFunctorCheckAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), DisplayGhostingAction::act(), DumpObjectsAction::act(), InitProblemAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), ResolveOptionalMaterialPropertiesAction::act(), SetAdaptivityOptionsAction::act(), SetupDampersAction::act(), SetupDebugAction::act(), SetupMeshCompleteAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), SetupQuadratureAction::act(), SetupResidualDebugAction::act(), SetupTimeIntegratorAction::act(), SetupTimeStepperAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), AddMFEMFESpaceAction::act(), AddMFEMFESpaceHierarchyAction::act(), AddMFEMQuadratureFunctionAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), ResolveMFEMSolversAction::act(), SetMFEMMeshFESpaceAction::act(), StartWebServerControlAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), PhysicsBase::addPetscPairsToPetscOptions(), AddVariableAction::addVariable(), PhysicsBase::checkIntegrityEarly(), CheckOutputAction::checkMaterialOutput(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), CheckOutputAction::checkVariableOutput(), PhysicsBase::getProblem(), PhysicsBase::getProblem(), AddVariableAction::getSubdomainIDs(), AddPeriodicBCAction::getVariables(), MaterialOutputAction::hasFunctorProperty(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), PhysicsBase::isTransient(), PhysicsBase::isVariableFV(), PhysicsBase::isVariableScalar(), AddPeriodicBCAction::onSetupPeriodicBoundary(), MaterialOutputAction::outputHelper(), ProjectedStatefulMaterialStorageAction::processProperty(), CreateExecutionerAction::setupAutoPreconditioning(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), PhysicsBase::solverVariableExists(), and PhysicsBase::variableExists().

◆ _registered_identifier

std::string Action::_registered_identifier
protectedinherited

Definition at line 151 of file Action.h.

Referenced by SetupMeshAction::act().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base
privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem
privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _specific_task_name

std::string Action::_specific_task_name
protectedinherited

This member will only be populated if this Action instance is only designed to handle one task.

This happens when an Action is registered with several pieces of syntax in which case separate instances are built to handle the different incoming parameter values.

Definition at line 159 of file Action.h.

Referenced by Action::specificTaskName().

◆ _type

const std::string& MooseBase::_type
protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _use_decomposed_index

const bool BatchMeshGeneratorAction::_use_decomposed_index
protected

Flag to indicate if the decomposed index should be used in the mesh name.

Definition at line 94 of file BatchMeshGeneratorAction.h.

Referenced by addMeshGenerators(), and BatchMeshGeneratorAction().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"
staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"
staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"
staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ NAME

constexpr auto MeshMetaDataInterface::NAME = "<empty>"
staticconstexprinherited

The data name used when initializing the Restartable interface for non-MeshGenerator objects.

Definition at line 33 of file MeshMetaDataInterface.h.

◆ name_param

const std::string MooseBase::name_param = "_object_name"
staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"
staticconstexprinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

◆ type_param

const std::string MooseBase::type_param = "_type"
staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_action_name_param

const std::string Action::unique_action_name_param = "_unique_action_name"
staticinherited

The name of the parameter that contains the unique action name.

Definition at line 41 of file Action.h.

Referenced by Action::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"
staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

◆ usingCombinedWarningSolutionWarnings

Action::usingCombinedWarningSolutionWarnings
inherited

Definition at line 55 of file Action.h.

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:34:26 for https://mooseframework.inl.gov by doxygen 1.9.8