https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Classes | 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
NEML2Action Class Reference

Action to set up NEML2 objects. More...

#include <NEML2Action.h>

Inheritance diagram for NEML2Action:
[legend]

Classes

struct  DerivativeMapping
 
struct  ParameterMapping
 
struct  VariableMapping
 

Public Types

using DataFileParameterType = DataFileName
 The parameter type this interface expects for a data file name.
 
typedef std::string SymbolName
 

Public Member Functions

 NEML2Action (const InputParameters &)
 
virtual void act () override
 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.
 
const MaterialPropertyName derivativePropertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
 Helper functions to generate the material property names for the arbitrary derivatives.
 
const MaterialPropertyName derivativePropertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
 Helper functions to generate the material property names for the first derivatives.
 
const MaterialPropertyName derivativePropertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
 Helper functions to generate the material property names for the second derivatives.
 
const MaterialPropertyName derivativePropertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const
 Helper functions to generate the material property names for the third derivatives.
 
const MaterialPropertyName propertyName (const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
 aliases for the deprecated old function names
 
const MaterialPropertyName propertyNameFirst (const MaterialPropertyName &base, const SymbolName &c1) const
 
const MaterialPropertyName propertyNameSecond (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
 
const MaterialPropertyName propertyNameThird (const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) 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

const NEML2ActionCommon & getCommonAction () const
 
const FileName & fname () const
 
void setupInputMappings (const NEML2ModelHandle &)
 Set up MOOSE-NEML2 input variable mappings.
 
void setupOutputMappings (const NEML2ModelHandle &)
 Set up MOOSE-NEML2 output variable mappings.
 
void setupDerivativeMappings (const NEML2ModelHandle &)
 Set up MOOSE-NEML2 derivative mappings.
 
void setupParameterMappings (const NEML2ModelHandle &)
 Set up MOOSE-NEML2 model parameter (value) mappings.
 
void setupParameterDerivativeMappings (const NEML2ModelHandle &)
 Set up MOOSE-NEML2 output-parameter-derivative mappings.
 
void checkStatefulConsistency (const NEML2ModelHandle &) const
 Validate consistency between the action configuration and the model's I/O before MOOSE wires up (stateful) material properties.
 
std::string resolveParameterName (const std::string &user_name, const std::map< std::string, std::vector< int64_t > > &param_shapes) const
 Resolve a user-written parameter name to a fully-qualified NEML2 parameter name.
 
NEML2Utils::MOOSEIOType inferMOOSEIOType (const std::string &name, bool is_scalar) const
 Infer the MOOSE IO type from the variable name (only scalar-typed variables can map to time/scalar/function/field quantities; everything else is a material property)
 
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
 

Static Protected Member Functions

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

Protected Attributes

FileName _fname
 Name of the NEML2 input file.
 
std::vector< std::string > _cli_args
 List of cli-args.
 
std::unique_ptr< NEML2ModelHandle > _model
 The neml2 model handle, used here only for introspection during setup.
 
std::vector< VariableMapping > _inputs
 MOOSE-NEML2 input variable mappings.
 
std::vector< VariableMapping > _outputs
 MOOSE-NEML2 output variable mappings.
 
std::vector< DerivativeMapping > _derivs
 MOOSE-NEML2 derivative mappings.
 
std::vector< ParameterMapping > _params
 MOOSE-NEML2 model parameter (value) mappings.
 
std::vector< DerivativeMapping > _param_derivs
 MOOSE-NEML2 output-parameter-derivative mappings.
 
const UserObjectName _executor_name
 Name of the NEML2Executor user object.
 
const UserObjectName _idx_generator_name
 Name of the NEML2BatchIndexGenerator user object.
 
const std::vector< SubdomainName > _block
 Blocks this sub-block action applies to.
 
std::vector< std::string > _skip_input_variables
 Input variables to skip (i.e., not to set up mappings for)
 
std::map< MaterialPropertyName, MaterialPropertyName > _initialize_output_values
 Material property initial conditions.
 
std::map< MaterialPropertyName, std::vector< OutputName > > _export_output_targets
 Material property additional outputs.
 
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

template<typename EnumType , typename T >
std::tuple< std::vector< EnumType >, std::vector< T > > getInputParameterMapping (const std::string &source_opt, const std::string &name_opt) const
 Get parameter lists for mapping between MOOSE and NEML2 quantities.
 
void printSummary () const
 Print a summary of the NEML2 model.
 
std::size_t getLongestMOOSEName () const
 Get the maximum length of all MOOSE names (for printing purposes)
 
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)
 

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.
 

Detailed Description

Action to set up NEML2 objects.

Definition at line 27 of file NEML2Action.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.

◆ SymbolName

Definition at line 24 of file DerivativeMaterialPropertyNameInterface.h.

Constructor & Destructor Documentation

◆ NEML2Action()

NEML2Action::NEML2Action ( const InputParameters &  params)

Definition at line 84 of file NEML2Action.C.

85 : Action(params),
86 _executor_name(isParamValid("executor_name")
87 ? getParam<std::string>("executor_name")
88 : "neml2_" + getParam<std::string>("model") + "_" + name()),
89 _idx_generator_name(isParamValid("batch_index_generator_name")
90 ? getParam<std::string>("batch_index_generator_name")
91 : "neml2_index_" + getParam<std::string>("model") + "_" + name()),
92 _block(getParam<std::vector<SubdomainName>>("block")),
93 _skip_input_variables(getParam<std::vector<std::string>>("skip_input_variables"))
94{
96
97 // Apply parameters under the common area, i.e., under [NEML2]
98 const auto & all_params = _app.getInputParameterWarehouse().getInputParameters();
99 auto & sub_block_params = *(all_params.find(uniqueActionName())->second.get());
100 const auto & common_action = getCommonAction();
101 sub_block_params.applyParameters(common_action.parameters());
102
103 // Set up optional output variable initialization
104 auto init_vars = getParam<std::vector<MaterialPropertyName>>("initialize_outputs");
105 auto init_vals = getParam<std::vector<MaterialPropertyName>>("initialize_output_values");
106 if (init_vars.size() != init_vals.size())
107 paramError("initialize_outputs",
108 "initialize_outputs should have the same length as initialize_output_values");
109 for (auto i : index_range(init_vars))
110 _initialize_output_values[init_vars[i]] = init_vals[i];
111
112 // Set up additional outputs for each requested material property
113 auto outputs = getParam<std::vector<MaterialPropertyName>>("export_outputs");
114 auto output_targets = getParam<std::vector<std::vector<OutputName>>>("export_output_targets");
115 if (outputs.size() != output_targets.size())
116 paramError("export_outputs",
117 "export_outputs should have the same length as export_output_targets");
118 for (auto i : index_range(outputs))
119 _export_output_targets[outputs[i]] = output_targets[i];
120
121#ifdef NEML2_ENABLED
122 // Route NEML2's log output to MOOSE's console before any model is built/introspected.
124
125 _cli_args = getParam<std::vector<std::string>>("cli_args");
126
127 // Build a model handle for setup-time introspection only (reading I/O names + base shapes to
128 // wire the MOOSE<->NEML2 transfers). cpp-eager reads the source 'input' (importing any 'load'
129 // Python extensions); cpp-aoti reads the compiled-artifact folder 'input'. 'cli_args' is
130 // currently not forwarded (NEML2 v3's load takes no extra parse arguments).
131 const bool eager = getParam<bool>("eager");
132 const auto load_files = getParam<std::vector<DataFileName>>("load");
133
134 if (!isParamValid("input"))
136 "input",
137 "'input' (the NEML2 source '.i' for cpp-eager, or the neml2-compile artifact folder for "
138 "cpp-aoti) is required.");
139 if (!eager && !load_files.empty())
140 paramError("load",
141 "The 'load' parameter is only valid with the cpp-eager runtime (eager=true).");
142
143 // Device list (default app device) + per-device chunk sizes; mirrors NEML2ModelInterface so the
144 // introspection handle and the runtime executor resolve devices identically.
145 auto devices = getParam<std::vector<std::string>>("device");
146 if (devices.empty())
147 devices = {at::Device(_app.getLibtorchDevice()).str()};
148 auto db = getParam<std::vector<unsigned int>>("device_batch");
149 if (db.empty())
150 db = {0};
151 if (db.size() != 1 && db.size() != devices.size())
152 paramError("device_batch", "'device_batch' must have length 1 or the same length as 'device'.");
153 const std::vector<std::size_t> batch_sizes(db.begin(), db.end());
154
155 // Host MPI communicator for the cpp-aoti CUDA scheduler (read at construction only).
156 const auto mpi_comm = comm().get();
157
158 _fname = getParam<DataFileName>("input");
160 std::string(_fname),
161 getParam<std::string>("model"),
162 devices,
163 batch_sizes,
164 &mpi_comm,
165 std::vector<std::string>(load_files.begin(), load_files.end()));
166#endif
167}
std::unique_ptr< NEML2ModelHandle > makeNEML2ModelHandle(bool eager, const std::string &input, const std::string &model, const std::vector< std::string > &devices, const std::vector< std::size_t > &batch_sizes, const void *comm, const std::vector< std::string > &load)
Construct a NEML2 model handle for the requested runtime.
Base class for actions.
Definition Action.h:38
MooseObjectName uniqueActionName() const
The unique name for accessing input parameters of this action in the InputParameterWarehouse.
Definition Action.h:108
MooseApp & _app
The MOOSE application this is associated with.
Definition MooseBase.h:375
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
const std::multimap< MooseObjectName, std::shared_ptr< InputParameters > > & getInputParameters(THREAD_ID tid=0) const
Return const reference to the map containing the InputParameter objects.
torch::DeviceType getLibtorchDevice() const
Get the device torch is supposed to be running on.
Definition MooseApp.h:114
InputParameterWarehouse & getInputParameterWarehouse()
Get the InputParameterWarehouse for MooseObjects.
Definition MooseApp.C:2876
const std::string & name() const
Get the name of the class.
Definition MooseBase.h:103
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
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
Definition MooseBase.h:406
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Definition MooseBase.h:199
const NEML2ActionCommon & getCommonAction() const
std::vector< std::string > _skip_input_variables
Input variables to skip (i.e., not to set up mappings for)
std::vector< std::string > _cli_args
List of cli-args.
std::unique_ptr< NEML2ModelHandle > _model
The neml2 model handle, used here only for introspection during setup.
const UserObjectName _idx_generator_name
Name of the NEML2BatchIndexGenerator user object.
std::map< MaterialPropertyName, std::vector< OutputName > > _export_output_targets
Material property additional outputs.
const std::vector< SubdomainName > _block
Blocks this sub-block action applies to.
const UserObjectName _executor_name
Name of the NEML2Executor user object.
std::map< MaterialPropertyName, MaterialPropertyName > _initialize_output_values
Material property initial conditions.
FileName _fname
Name of the NEML2 input file.
const Parallel::Communicator & comm() const
void redirectLogsToConsole(const ConsoleStream &console)
Route NEML2's log output into MOOSE's console.
Definition NEML2Utils.C:45
void assertNEML2Enabled()
Assert that NEML2 is enabled.
Definition NEML2Utils.C:90
auto index_range(const T &sizable)

Member Function Documentation

◆ act()

void NEML2Action::act ( )
overridevirtual

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

Implements Action.

Definition at line 180 of file NEML2Action.C.

181{
182}

◆ 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)
136 else // we added it
137 unique_object_id++;
138
139 return added;
140}
std::shared_ptr< MooseMesh > & _mesh
Definition Action.h:174
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
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition Factory.C:68
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
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
const std::string & getBase() const
bool addRelationshipManager(std::shared_ptr< RelationshipManager > relationship_manager)
Transfers ownership of a RelationshipManager to the application for lifetime management.
Definition MooseApp.C:3000
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
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition MooseMesh.h:95
Factory & _factory
The Factory associated with the MooseApp.
RelationshipManagers are used for describing what kinds of non-local resources are needed for an obje...
std::string stringify(const T &t)
conversion to string
Definition Conversion.h:65
RelationshipManagerType
Main types of Relationship Managers.

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
162 input_rm_type, moose_object_pars, rm_name, rm_type, rm_input_parameter_func) ||
163 added;
164 }
165
166 return added;
167}
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
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.

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); }
std::set< std::string > _all_tasks
A list of all the tasks that this Action will satisfy.
Definition Action.h:166

◆ 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}
void setHitNode(const std::string &param, const hit::Node &node, const SetParamHitNodeKey)
Sets the hit node associated with the parameter param to node.
const hit::Node * getHitNode(const std::string &param) const

◆ 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}
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
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();
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}
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition MooseApp.C:2418
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
Definition MooseApp.h:870
const hit::Node * getHitNode() const
Definition MooseBase.h:136
std::string messagePrefix(const bool hit_prefix=true) const
Definition MooseBase.h:256
void mooseConsole()
Send current output buffer to Console output objects.
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:51

◆ 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}
MooseApp & _app
The MOOSE application this is associated with.
Definition MooseBase.h:375
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
const InputParameters & _pars
The object's parameters.
Definition MooseBase.h:384

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

◆ checkStatefulConsistency()

void NEML2Action::checkStatefulConsistency ( const NEML2ModelHandle &  model) const
protected

Validate consistency between the action configuration and the model's I/O before MOOSE wires up (stateful) material properties.

Guards against two configurations that otherwise crash during stateful material property initialization: (1) 'initialize_outputs' naming a variable that is not a model output, and (2) an old (stateful) material input 'var~N' whose base 'var' is neither a current model input nor a model output (so nothing declares the property whose old value is requested).

Definition at line 637 of file NEML2Action.C.

638{
639 // Render a list of variable names for diagnostics.
640 auto names_list = [](const std::vector<std::string> & names)
641 {
642 std::string s;
643 for (const auto & n : names)
644 s += (s.empty() ? "" : ", ") + n;
645 return s;
646 };
647
648 // Guard 1: every variable named in 'initialize_outputs' must be an actual model output. Output
649 // retrievers (which carry the initialization value) are only created for model outputs, so a name
650 // that is not an output silently has no declarer and crashes during stateful initialization.
651 for (const auto & pair : _initialize_output_values)
652 {
653 const std::string out_name = pair.first;
654 if (!contains(model.output_names(), out_name))
655 paramError("initialize_outputs",
656 "'",
657 out_name,
658 "' is not an output of the NEML2 model and therefore cannot be initialized. "
659 "Available model outputs are: ",
660 names_list(model.output_names()),
661 ".");
662 }
663
664 // Guard 2: an old (stateful) material input 'var~N' requires the model to either take 'var' as a
665 // current input or produce it as an output. MOOSE sources the old value from the material
666 // property declared either by another material (when 'var' is also a current model input, e.g.
667 // strain provided by the mechanics) or by this model's output retriever (when 'var' is a model
668 // output). If the model does neither, nothing declares the property whose old value is requested,
669 // and MOOSE segfaults during stateful material property initialization. The common offender is a
670 // state variable pruned from the top-level outputs because a downstream model consumes it (e.g.
671 // GeneralElasticity reads 'orientation'); the fix is to add it to the model's
672 // 'additional_outputs'.
673 for (const auto & input : _inputs)
674 if (input.history_order > 0 && input.moose_type == NEML2Utils::MOOSEIOType::MATERIAL &&
675 !contains(model.input_names(), input.name) && !contains(model.output_names(), input.name))
677 "The NEML2 model takes the old value of '",
678 input.name,
679 "' (",
680 lagName(input.name, input.history_order),
681 ") as an input, but the model neither takes '",
682 input.name,
683 "' as a current input nor produces it as an output, so MOOSE has no source for its "
684 "old value. If '",
685 input.name,
686 "' is a state variable, add it to the model's 'additional_outputs' in the NEML2 "
687 "input file so that the model produces it. Model inputs: ",
688 names_list(model.input_names()),
689 "; model outputs: ",
690 names_list(model.output_names()),
691 ".");
692}
if(!dmm->_nl) SETERRQ(PETSC_COMM_WORLD
std::vector< VariableMapping > _inputs
MOOSE-NEML2 input variable mappings.
virtual const std::vector< std::string > & output_names() const =0
std::string lagName(const std::string &base, int lag)
Inverse of parseLag: build the variable name for a base name + lag.
Definition NEML2Utils.h:71
bool contains(std::string_view superstring, std::string_view substring)

◆ 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}
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.
Factory & getFactory()
Retrieve a writable reference to the Factory associated with this App.
Definition MooseApp.h:404
MooseObjectName uniqueName() const
Definition MooseBase.C:69
A class for storing an input parameter name.

◆ derivativePropertyName()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyName ( const MaterialPropertyName &  base,
const std::vector< SymbolName > &  c 
) const
inherited

Helper functions to generate the material property names for the arbitrary derivatives.

Definition at line 16 of file DerivativeMaterialPropertyNameInterface.C.

18{
19 // to obtain well defined names we sort alphabetically
20 std::vector<SymbolName> a(c);
21 std::sort(a.begin(), a.end());
22
23 // derivative order
24 unsigned int order = a.size();
25 if (order == 0)
26 return base;
27
28 // build the property name as a stringstream
29 std::stringstream name;
30
31 // build numerator
32 name << 'd';
33 if (order > 1)
34 name << '^' << order;
35 name << base << '/';
36
37 // build denominator with 'pretty' names using exponents rather than repeat multiplication
38 unsigned int exponent = 1;
39 for (unsigned i = 1; i <= order; ++i)
40 {
41 if (i == order || a[i - 1] != a[i])
42 {
43 name << 'd' << a[i - 1];
44 if (exponent > 1)
45 name << '^' << exponent;
46 exponent = 1;
47 }
48 else
49 exponent++;
50 }
51
52 return name.str();
53}
std::string name(const ElemQuality q)

Referenced by DerivativeMaterialInterface< T >::declareKokkosPropertyDerivative(), DerivativeMaterialPropertyNameInterface::derivativePropertyNameSecond(), DerivativeMaterialPropertyNameInterface::derivativePropertyNameThird(), and DerivativeMaterialPropertyNameInterface::propertyName().

◆ derivativePropertyNameFirst()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyNameFirst ( const MaterialPropertyName &  base,
const SymbolName &  c1 
) const
inherited

Helper functions to generate the material property names for the first derivatives.

Definition at line 56 of file DerivativeMaterialPropertyNameInterface.C.

58{
59 return "d" + base + "/d" + c1;
60}

Referenced by DerivativeMaterialPropertyNameInterface::propertyNameFirst(), setupDerivativeMappings(), and setupParameterDerivativeMappings().

◆ derivativePropertyNameSecond()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyNameSecond ( const MaterialPropertyName &  base,
const SymbolName &  c1,
const SymbolName &  c2 
) const
inherited

Helper functions to generate the material property names for the second derivatives.

Definition at line 63 of file DerivativeMaterialPropertyNameInterface.C.

65{
66 return derivativePropertyName(base, {c1, c2});
67}
const MaterialPropertyName derivativePropertyName(const MaterialPropertyName &base, const std::vector< SymbolName > &c) const
Helper functions to generate the material property names for the arbitrary derivatives.

Referenced by DerivativeMaterialPropertyNameInterface::propertyNameSecond().

◆ derivativePropertyNameThird()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::derivativePropertyNameThird ( const MaterialPropertyName &  base,
const SymbolName &  c1,
const SymbolName &  c2,
const SymbolName &  c3 
) const
inherited

Helper functions to generate the material property names for the third derivatives.

Definition at line 70 of file DerivativeMaterialPropertyNameInterface.C.

75{
76 return derivativePropertyName(base, {c1, c2, c3});
77}

Referenced by DerivativeMaterialPropertyNameInterface::propertyNameThird().

◆ 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)
50 solution_invalidity.printDebug(invalid_solution_id);
51 return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
52}
bool immediatelyPrintInvalidSolution() const
Whether or not the solution invalid warnings are printed out immediately.
SolutionInvalidity & solutionInvalidity()
Get the SolutionInvalidity for this app.
Definition MooseApp.h:182
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition MooseBase.h:87
const FEProblemBase * _si_problem
A pointer to FEProblem base.
const MooseBase & _si_moose_base
The MooseBase that owns this interface.
void printDebug(InvalidSolutionID _invalid_solution_id) const
Immediately print the section and message for debug purpose.
SolutionInvalidityRegistry & getSolutionInvalidityRegistry()
Get the global SolutionInvalidityRegistry singleton.

◆ fname()

const FileName & NEML2Action::fname ( ) const
inlineprotected

Definition at line 41 of file NEML2Action.h.

41{ return _fname; }

Referenced by printSummary().

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

◆ getCommonAction()

const NEML2ActionCommon & NEML2Action::getCommonAction ( ) const
protected

Definition at line 170 of file NEML2Action.C.

171{
172 auto common_block = _awh.getActions<NEML2ActionCommon>();
173 mooseAssert(common_block.size() == 1, "There must exist one and only one common NEML2 action.");
174 return *common_block[0];
175}
std::vector< const T * > getActions()
Retrieve all actions in a specific type ordered by their names.
ActionWarehouse & _awh
Reference to ActionWarehouse where we store object build by actions.
Definition Action.h:169
Input parameters common to all block-restricted NEML2Actions.

Referenced by NEML2Action().

◆ 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}
const ParallelParamObject & _parent
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}
std::string getDataFilePath(const std::string &relative_path) const
Returns the path of a data file for a given relative file path.

◆ 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;
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}
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
Definition MooseBase.h:299
void mooseInfo(Args &&... args) const
Definition MooseBase.h:334
Scoped helper for setting Moose::_throw_on_error during this scope.
Definition Moose.h:308
@ DATA
From installed/in-tree data.
Path getPath(std::string path, const GetPathOptions &options={})
Get the data path for a given path, searching the registered data.
Representation of a data file path.
std::optional< std::string > data_name
The name of the data registry the file came from (with context == DATA)
Context context
Context for the file (where it came from)

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}

◆ getInputParameterMapping()

template<typename EnumType , typename T >
std::tuple< std::vector< EnumType >, std::vector< T > > NEML2Action::getInputParameterMapping ( const std::string &  source_opt,
const std::string &  name_opt 
) const
inlineprivate

Get parameter lists for mapping between MOOSE and NEML2 quantities.

Definition at line 150 of file NEML2Action.h.

151 {
152 const auto moose_types = getParam<MultiMooseEnum>(source_opt).getSetValueIDs<EnumType>();
153 const auto neml2_names = getParam<std::vector<T>>(name_opt);
154
155 if (moose_types.size() != neml2_names.size())
156 paramError(source_opt, source_opt, " must have the same length as ", name_opt);
157
158 return {moose_types, neml2_names};
159 }

◆ getLongestMOOSEName()

std::size_t NEML2Action::getLongestMOOSEName ( ) const
private

Get the maximum length of all MOOSE names (for printing purposes)

Definition at line 759 of file NEML2Action.C.

760{
761 std::size_t max_moose_name_length = 0;
762 for (const auto & input : _inputs)
763 {
764 auto n = input.name.size();
765 if (input.history_order > 0)
766 n += 6; // 6 is the length of "(old) "
767 max_moose_name_length = std::max(max_moose_name_length, n);
768 }
769 for (const auto & output : _outputs)
770 max_moose_name_length = std::max(max_moose_name_length, output.name.size());
771 for (const auto & deriv : _derivs)
772 max_moose_name_length = std::max(max_moose_name_length, deriv.name.size());
773 return max_moose_name_length;
774}
std::vector< VariableMapping > _outputs
MOOSE-NEML2 output variable mappings.
std::vector< DerivativeMapping > _derivs
MOOSE-NEML2 derivative mappings.
auto max(const L &left, const R &right)
Real deriv(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ 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 }
virtual std::string meshPropertyPrefix(const std::string &data_name) const
The default prefix to use for getting/seeing if mesh properties exist.

◆ 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}
bool hasMeshProperty(const std::string &data_name, const std::string &prefix) const
const RestartableDataValue & getMeshPropertyInternal(const std::string &data_name, const std::string &prefix) const
Helper for getting a mesh property.
void mooseErrorInternal(Args &&... args) const
Helper for forwarding a mooseError to an object's mooseError if it is available (said error will prov...
Concrete definition of a parameter value for a specified type.
const T & get() const
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ 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{
58 meshPropertyName(data_name, prefix), MooseApp::MESH_META_DATA, 0);
59}
MooseApp & _meta_data_app
Reference to the application.
static std::string meshPropertyName(const std::string &data_name, const std::string &prefix)
RestartableDataValue & getRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname, THREAD_ID tid)
Definition MooseApp.C:2520
static const RestartableDataMapName MESH_META_DATA
Definition MooseApp.h:133

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(), MooseMesh::cacheChangedLists(), ReporterTransferInterface::checkHasReporterValue(), LinearFVGradientManager::checkRestartedGradientHistory(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), GreaterThanLessThanPostprocessor::execute(), Terminator::execute(), WorkBalance::execute(), FEProblemSolve::FEProblemSolve(), RadialAverage::finalize(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), SubProblem::numThreads(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), AuxiliarySystem::registerFVGradient(), 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(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), Console::Console(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DiffusionPhysicsBase::DiffusionPhysicsBase(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), SurfaceDelaunayGeneratorBase::fillDelaunayOptions(), 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(), 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(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), 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(), VectorOfPostprocessors::VectorOfPostprocessors(), and XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

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

◆ 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(); }
bool hasBase() const

◆ 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{
38}
bool hasRestartableMetaData(const std::string &name, const RestartableDataMapName &metaname) const
Definition MooseApp.C:2510

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}

◆ inferMOOSEIOType()

NEML2Utils::MOOSEIOType NEML2Action::inferMOOSEIOType ( const std::string &  name,
bool  is_scalar 
) const
protected

Infer the MOOSE IO type from the variable name (only scalar-typed variables can map to time/scalar/function/field quantities; everything else is a material property)

Definition at line 347 of file NEML2Action.C.

348{
349 // only scalar-typed variables can come from a scalar variable, function, or field variable
350 if (is_scalar)
351 {
352 bool is_time = _problem->isTransient() && (name == "t" || name == "time");
353 bool has_scalar = _problem->hasScalarVariable(name);
354 bool has_func = _problem->hasFunction(name);
355 bool has_var = _problem->hasVariable(name);
356 if (int(is_time) + int(has_scalar) + int(has_func) + int(has_var) > 1)
357 mooseError("Trying to infer MOOSE data type for NEML2 variable ",
358 name,
359 ". The name matches multiple types (",
360 (is_time ? "time " : ""),
361 (has_scalar ? "scalar variable " : ""),
362 (has_func ? "function " : ""),
363 (has_var ? "variable " : ""),
364 "). To avoid ambiguity, please explicitly specify the type in the NEML2 action.");
365 if (is_time)
367 if (has_scalar)
369 if (has_func)
371 if (has_var)
373 // if neither function nor variable exists, let's assume it's a material property
374 // note that we can't explicitly check if a material property with the given name exists,
375 // because materials are added _after_ user objects (see Moose.C)
376 }
377
378 // non-scalar can only come from material properties
380}
void ErrorVector unsigned int
std::shared_ptr< FEProblemBase > & _problem
Convenience reference to a problem this action works on.
Definition Action.h:178

Referenced by setupInputMappings().

◆ 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 {
208 }
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was set by the user.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MFEMNewtonNonlinearSolver::ConstructSolver(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), MeshDiagnosticsGenerator::generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), MFEMEigenproblem::getRHSCoefficient(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), LibtorchNeuralNetControl::initialSetup(), ElementSubdomainModifierBase::initialSetup(), LibtorchNeuralNetControl::loadControlNeuralNetFromFile(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMEigenproblem::MFEMEigenproblem(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MooseApp::MooseApp(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), 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(), MooseApp::setMFEMDevice(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), MFEMHypreBoomerAMG::SetSolverParameters(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TriToQuadConverter::TriToQuadConverter(), XYFrontalDelaunayGenerator::XYFrontalDelaunayGenerator(), 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); }
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another,...

Referenced by GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), AddVariableAction::act(), AutoCheckpointAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CopyNodalVarsAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshCompleteAction::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(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), 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(), DiffusionPhysicsBase::DiffusionPhysicsBase(), 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(), SurfaceDelaunayGeneratorBase::fillDelaunayOptions(), 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(), GeneratedMeshGenerator::GeneratedMeshGenerator(), 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(), PNGOutput::makePNG(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MooseApp::MooseApp(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< RealEigenVector >::MooseVariableFV(), 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(), NEML2Action(), 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::setFileBaseInternal(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, T >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SolutionUserObjectBase::SolutionUserObjectBase(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), PIDTransientControl::timestepSetup(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve(), 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}
static constexpr auto SYSTEM
The system name used when initializing the Restartable interface.

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}
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}
static const std::string main_app_name
The name for the "main" moose application.
Definition AppFactory.h:68
bool isMooseBaseObject() const
const std::string & getObjectType() const
const std::string & getObjectName() const
std::string hitMessagePrefix(const hit::Node &node)
Get the prefix to be associated with a hit node for a message.
Definition Moose.C:915

◆ 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 {
320 _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
321 }
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(), MooseApp::MooseApp(), and MooseApp::setupOptions().

◆ mooseDeprecated() [2/2]

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

◆ 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 {
330 _console, false, true, false, messagePrefix(true), std::forward<Args>(args)...);
331 }

Referenced by MooseApp::MooseApp().

◆ 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 {
282 repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
283 /* with_prefix = */ true);
284 }
std::string formatMooseDocumentedError(const std::string &repo_name, const unsigned int issue_num, const std::string &msg)
Formats a documented error.
Definition MooseError.C:140

◆ 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(), 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(), Function::average(), BatchMeshGeneratorAction::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(), FVFluxBC::checkFaceIntegrity(), FVInterfaceKernel::checkFaceIntegrity(), PhysicsVariableCoordinator::checkFVAdjacency(), 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(), checkStatefulConsistency(), 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(), AdvancedExtruderGenerator::computeNodeNormals(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MaterialBase::computeProperties(), 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(), FVInterfaceKernel::faceArg1(), FVInterfaceKernel::faceArg2(), MultiApp::fillPositions(), MooseApp::finalizeRestore(), Transfer::find_sys(), PhysicsVariableCoordinator::findOrCreate(), 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(), EigenExecutionerBase::getEigenSystemConvergence(), 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(), SubProblem::getVariableHelper(), 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(), inferMOOSEIOType(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), EigenExecutionerBase::init(), TransientBase::init(), MFEMMesh::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(), LineSearch::lineSearch(), LibtorchNeuralNetControl::loadControlNeuralNetFromFile(), MooseApp::loadLibraryAndDependencies(), ReporterPointMarker::markerSetup(), Material::Material(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MooseApp::MooseApp(), 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(), MFEMFunctorMaterial::processLiterals(), MultiApp::readCommandLineArguments(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), PhysicsVariableCoordinator::requestVariable(), resolveParameterName(), 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(), Split::setup(), TransientMultiApp::setupApp(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), setupDerivativeMappings(), setupInputMappings(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), setupOutputMappings(), setupParameterDerivativeMappings(), setupParameterMappings(), 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(), Moose::Kokkos::ResidualObject::variable(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), AddVariableAction::variableType(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), WebServerControl::WebServerControl(), WebServerControl::writePortFile(), MFEMMesh::writeRecoveryFiles(), 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 {
135 _meta_data_object->mooseError(std::forward<Args>(args)...);
136 mooseError(std::forward<Args>(args)...);
137 }
const MooseObject *const _meta_data_object
The MooseObject (if any); used for better error handling.

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

◆ 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 }
void mooseWarningStream(S &oss, Args &&... args)
Definition MooseError.h:197

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

◆ 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(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MFEMRefinementMarker::MFEMRefinementMarker(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), 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 }
const std::string & _name
The name of this class.
Definition MooseBase.h:381

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(), MFEMComplexWeakForm::addBoundaryCondition(), MFEMWeakForm::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), MFEMProblem::addDefaultProblemComposer(), MFEMProblem::addDefaultWeakForm(), 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::addFVGradientMethod(), 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(), MFEMComplexWeakForm::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(), MFEMProblem::addObject(), FEProblemBase::addObject(), InitialConditionWarehouse::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), UserObjectBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), InitialConditionBase::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), MFEMProblem::addProblemComposer(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), AddActionComponentAction::addRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), WebServerControl::addServerActionsInternal(), PhysicsBase::addSharedAuxVariable(), PhysicsBase::addSharedSolverVariable(), 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(), MFEMProblem::addWeakForm(), 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(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), 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(), checkCoupledScalarVariableBlocks(), FEProblemBase::checkDependMaterialsHelper(), FVFluxBC::checkFaceIntegrity(), FVInterfaceKernel::checkFaceIntegrity(), TaggingInterface::checkForNans(), SamplerBase::checkForStandardFieldVariableType(), PhysicsVariableCoordinator::checkFVAdjacency(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), NonlinearSystemBase::checkKernelCoverage(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), LinearFVGradientManager::checkRestartedGradientHistory(), FEProblemBase::checkUserObjectNameCollision(), BlockRestrictable::checkVariable(), DomainUserObject::checkVariable(), Coupleable::checkWritableVar(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), 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(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), 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(), MFEMCoordinateTransformations::declareRZCoefficients(), 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(), FVInterfaceKernel::faceArg1(), FVInterfaceKernel::faceArg2(), NEML2ModelExecutor::failedInputDumpName(), 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(), AdvancedExtruderGenerator::generate(), BoundaryDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), BSplineCurveGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::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::getFVGradientMethod(), FEProblemBase::getFVGradientMethod(), 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(), TorchFEInterpolation::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(), LinearFVGradientManager::gradientStateVectorName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasDistribution(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), FEProblemBase::hasFVGradientMethod(), FEProblemBase::hasFVInterpolationMethod(), MeshInfo::hasItem(), MooseApp::hasMeshGenerator(), MFEMProblem::hasMFEMObject(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), 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(), MFEMScalarQuadratureFunction::initialSetup(), MFEMVectorQuadratureFunction::initialSetup(), Console::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), NodalVariableValue::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppGeneralFieldFunctorTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), BoundaryMeshBuilder::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(), MooseApp::MooseApp(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< T >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), 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(), PointInUnionCheckUO::PointInUnionCheckUO(), 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(), MoveNodesByParsedExpressionModifier::setupNodalOutputVariables(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), LinearFVGradientReader::stateComponents(), 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(), BoundaryMeshBuilder::surfaceElementSet(), TorchFEInterpolation::syncWithMainThread(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< OutputType >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), TorchPreKernel::TorchPreKernel(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), MultiAppMFEMCopyTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), TransientMultiApp::TransientMultiApp(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVQpFluxBC::uOnGhost(), FVQpFluxBC::uOnUSub(), UserObjectBase::UserObjectBase(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), BreakMeshByBlockGenerator::validParams(), MeshInfo::validParams(), MFEMExecutedObject::variableDependencyKey(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), MFEMExecutedObject::vectorPostprocessorDependencyKey(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), MooseApp::writeRestartableMetaData(), and XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

◆ 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}
void paramError(const std::string &param, Args... args) const
Emits a parameter error prefixed with the parameter location and object information if available.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), CommonOutputAction::act(), SetupDebugAction::act(), ADArrayIntegratedBC::ADArrayIntegratedBC(), ADArrayRobinBC::ADArrayRobinBC(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ReporterPointSource::addPoints(), DiffusionPhysicsBase::addPostprocessors(), 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::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundaryIntegralValueConstraint::BoundaryIntegralValueConstraint(), BoundaryLinearFVFluxIntegral::BoundaryLinearFVFluxIntegral(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMFESpaceHierarchy::buildHierarchy(), MFEMMesh::buildMesh(), TimeSequenceStepperBase::buildSequence(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), checkComponent(), Moose::Kokkos::ParsedObjectBase::checkDuplicateSymbols(), SamplerBase::checkForStandardFieldVariableType(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), SurfaceDelaunayGeneratorBase::checkInteriorPoints(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), PostprocessorInterface::checkParam(), MortarConsumerInterface::checkPetrovGalerkinQuadraticFaces(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), checkStatefulConsistency(), 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(), AdvancedExtruderGenerator::computeNodeNormals(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), MFEMNewtonNonlinearSolver::ConstructSolver(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), MultiAppGeneralFieldTransfer::correctSolutionVectorValues(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CumulativeTimeAverageFunctorAux::CumulativeTimeAverageFunctorAux(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), 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(), FunctorNodalCorrector::execute(), 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(), MeshTriangulationUtils::finalizeTriangulation(), 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(), FunctorNodalCorrector::FunctorNodalCorrector(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), 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(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), CombinerGenerator::generate(), ConcentricCircleMeshGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), MoveBoundaryNodesToCurveGenerator::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(), TriToQuadConverter::generate(), UniqueExtraIDMeshGenerator::generate(), XYFrontalDelaunayGenerator::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(), getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), Sampler::getSampleRow(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), AddPeriodicBCAction::getVariables(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), TimeIntegrator::init(), MFEMTransient::init(), FEProblemBase::init(), MultiApp::init(), MFEMWeakFormBase::initEquationSystem(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), ReferenceResidualConvergence::initialSetup(), Axisymmetric2D3DSolutionFunction::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(), PointInPolyhedronCheckUO::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(), LinearFVGradientAux::LinearFVGradientAux(), Moose::MFEM::LinearSolverBase::LinearSolverBase(), 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(), MFEMEigenproblem::MFEMEigenproblem(), MFEMFunctorMaterial::MFEMFunctorMaterial(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorMatrixMaterial::MFEMGenericFunctorMatrixMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMMultiAppTransfer::MFEMMultiAppTransfer(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMSumAux::MFEMSumAux(), MFEMVariable::MFEMVariable(), MFEMWeakFormProblemComposerBase::MFEMWeakFormProblemComposerBase(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveBoundaryNodesToCurveGenerator::MoveBoundaryNodesToCurveGenerator(), MoveNodeGenerator::MoveNodeGenerator(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), TriToQuadConverter::moveSurvivingTriangles(), 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(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), NumDOFs::NumDOFs(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), MeshTriangulationUtils::outerBoundaryIds(), 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(), PointInPolyhedronBaseUO::PointInPolyhedronBaseUO(), PointInSignedFunctionCheckUO::PointInSignedFunctionCheckUO(), PointInUnionCheckUO::PointInUnionCheckUO(), 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(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), Moose::MFEM::LinearSolverBase::SetPreconditionerImpl(), MFEMHypreAME::SetPreconditionerImpl(), MFEMHypreFGMRES::SetPreconditionerImpl(), MFEMHypreGMRES::SetPreconditionerImpl(), MFEMHyprePCG::SetPreconditionerImpl(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), CylinderComponent::setupComponent(), setupDerivativeMappings(), setupInputMappings(), MultiSystemSolveObject::setupMultiSystemFixedPointRelaxationFactors(), MoveNodesByParsedExpressionModifier::setupNodalOutputVariables(), setupParameterDerivativeMappings(), SetupQuadratureAction::SetupQuadratureAction(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), XYFrontalDelaunayGenerator::targetArea(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), TorchPreKernel::TorchPreKernel(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), CylinderComponent::translation(), MeshTriangulationUtils::triangulateWithDelaunay(), TriToQuadConverter::TriToQuadConverter(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), UserObjectBase::UserObjectBase(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), SolutionAux::validateVariable(), MFEMProblem::validateVariableNumericType(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYFrontalDelaunayGenerator::XYFrontalDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ 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(), MFEMProblem::addDefaultWeakForm(), MFEMEigenproblem::addDefaultWeakForm(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVGradientMethod(), 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(), MFEMProblem::addObject(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), MFEMProblem::addProblemComposer(), 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(), MFEMProblem::addWeakForm(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), assemble_l2(), Moose::assemble_matrix(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), MeshGenerator::checkGetMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), 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(), MooseApp::MooseApp(), 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(), 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}
std::string paramMessage(const std::string &param, Args... args) const

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FEProblemBase::execMultiApps(), 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

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )
inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

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

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

◆ printSummary()

void NEML2Action::printSummary ( ) const
private

Print a summary of the NEML2 model.

Definition at line 695 of file NEML2Action.C.

696{
697 if (!_app.parameters().have_parameter<bool>("parse_neml2_only"))
698 return;
699
700 // Save formatting of the output stream so that we can restore it later
701 const auto flags = _console.flags();
702
703 // Default width for the summary
704 const int width = 79;
705
706 _console << std::endl;
707 _console << COLOR_CYAN << std::setw(width) << std::setfill('*') << std::left
708 << "NEML2 MATERIAL MODEL SUMMARY BEGIN " << std::setfill(' ') << COLOR_DEFAULT
709 << std::endl;
710
711 // Metadata
712 _console << "NEML2 input file location: " << fname() << std::endl;
713 _console << "NEML2 action path: " << parameters().blockFullpath() << std::endl;
714
715 // List inputs and outputs of the model
716 _console << COLOR_CYAN << std::setw(width) << std::setfill('-') << std::left
717 << "Material model structure " << std::setfill(' ') << COLOR_DEFAULT << std::endl;
718 _console << "NEML2 model inputs:" << std::endl;
719 for (const auto & iname : _model->input_names())
720 _console << " - " << iname << std::endl;
721 _console << "NEML2 model outputs:" << std::endl;
722 for (const auto & oname : _model->output_names())
723 _console << " - " << oname << std::endl;
724
725 // List transfer between MOOSE and NEML2
726 if (!_app.parameters().get<bool>("parse_neml2_only"))
727 {
728 _console << COLOR_CYAN << std::setw(width) << std::setfill('-') << std::left
729 << "Transfer between MOOSE and NEML2 " << std::setfill(' ') << COLOR_DEFAULT
730 << std::endl;
731
732 _console << "MOOSE --> NEML2" << std::endl;
733
734 // List input transfer, MOOSE -> NEML2
735 for (const auto & input : _inputs)
736 _console << " - " << (input.history_order > 0 ? ("(old) " + input.name) : input.name) << " ("
737 << NEML2Utils::stringify(input.moose_type) << ")" << std::endl;
738
739 _console << "MOOSE <-- NEML2" << std::endl;
740
741 // List output transfer, NEML2 -> MOOSE
742 for (const auto & output : _outputs)
743 _console << " - " << output.name << std::endl;
744
745 // List derivative transfer, NEML2 -> MOOSE
746 for (const auto & deriv : _derivs)
747 _console << " - " << deriv.name << std::endl;
748 }
749
750 _console << COLOR_CYAN << std::setw(width) << std::setfill('*') << std::left
751 << "NEML2 MATERIAL MODEL SUMMARY END " << std::setfill(' ') << COLOR_DEFAULT << std::endl
752 << std::endl;
753
754 // Restore the formatting of the output stream
755 _console.flags(flags);
756}
std::ios_base::fmtflags flags() const
Return the current flags.
std::string blockFullpath() const
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
const FileName & fname() const
Definition NEML2Action.h:41
std::string stringify(MOOSEIOType type)
Definition NEML2Utils.C:56

◆ propertyName()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyName ( const MaterialPropertyName &  base,
const std::vector< SymbolName > &  c 
) const
inlineinherited

aliases for the deprecated old function names

Definition at line 58 of file DerivativeMaterialPropertyNameInterface.h.

60 {
61 mooseDeprecated("This function was renamed to 'derivativePropertyName'");
62 return derivativePropertyName(base, c);
63 }
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition MooseError.h:363

◆ propertyNameFirst()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyNameFirst ( const MaterialPropertyName &  base,
const SymbolName &  c1 
) const
inlineinherited

Definition at line 64 of file DerivativeMaterialPropertyNameInterface.h.

66 {
67 mooseDeprecated("This function was renamed to 'derivativePropertyNameFirst'");
68 return derivativePropertyNameFirst(base, c1);
69 }
const MaterialPropertyName derivativePropertyNameFirst(const MaterialPropertyName &base, const SymbolName &c1) const
Helper functions to generate the material property names for the first derivatives.

◆ propertyNameSecond()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyNameSecond ( const MaterialPropertyName &  base,
const SymbolName &  c1,
const SymbolName &  c2 
) const
inlineinherited

Definition at line 70 of file DerivativeMaterialPropertyNameInterface.h.

73 {
74 mooseDeprecated("This function was renamed to 'derivativePropertyNameSecond'");
75 return derivativePropertyNameSecond(base, c1, c2);
76 }
const MaterialPropertyName derivativePropertyNameSecond(const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2) const
Helper functions to generate the material property names for the second derivatives.

◆ propertyNameThird()

const MaterialPropertyName DerivativeMaterialPropertyNameInterface::propertyNameThird ( const MaterialPropertyName &  base,
const SymbolName &  c1,
const SymbolName &  c2,
const SymbolName &  c3 
) const
inlineinherited

Definition at line 77 of file DerivativeMaterialPropertyNameInterface.h.

81 {
82 mooseDeprecated("This function was renamed to 'derivativePropertyNameThird'");
83 return derivativePropertyNameThird(base, c1, c2, c3);
84 }
const MaterialPropertyName derivativePropertyNameThird(const MaterialPropertyName &base, const SymbolName &c1, const SymbolName &c2, const SymbolName &c3) const
Helper functions to generate the material property names for the third derivatives.

◆ 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}
const T * queryParam(const std::string &name) const
Query a parameter.

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{
59 _si_moose_base.type(), message, warning);
60}
const std::string & type() const
Get the type of this class.
Definition MooseBase.h:93
InvalidSolutionID registerInvalidity(const std::string &object_type, const std::string &message, const bool warning)
Call to register an invalid calculation.

◆ 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}
std::string timedSectionName(const std::string &section_name) const
PerfID sectionID(const std::string &section_name) const
Given a name return the PerfID @section_name The name of the section.
PerfID registerSection(const std::string &section_name, const unsigned int level)
Call to register a named section for timing.
PerfGraphRegistry & getPerfGraphRegistry()
Get the global PerfGraphRegistry singleton.

◆ 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))
80 timedSectionName(section_name), level, live_message, print_dots);
81 else
82 return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
83}

◆ resolveParameterName()

std::string NEML2Action::resolveParameterName ( const std::string &  user_name,
const std::map< std::string, std::vector< int64_t > > &  param_shapes 
) const
protected

Resolve a user-written parameter name to a fully-qualified NEML2 parameter name.

Accepts an exact match or an unambiguous trailing ".<name>" suffix of a registered parameter. The candidates are the keys of the model's parameter_base_shapes() map.

Definition at line 535 of file NEML2Action.C.

538{
539 std::vector<std::string> param_names;
540 for (const auto & [p, s] : param_shapes)
541 param_names.push_back(p);
542
543 if (contains(param_names, user_name))
544 return user_name;
545
546 // Accept an unambiguous trailing ".<user_name>" suffix (e.g. "E" -> "model.E").
547 std::vector<std::string> matches;
548 const std::string suffix = "." + user_name;
549 for (const auto & p : param_names)
550 if (p.size() > suffix.size() && p.compare(p.size() - suffix.size(), suffix.size(), suffix) == 0)
551 matches.push_back(p);
552
553 if (matches.size() == 1)
554 return matches[0];
555
556 std::string available;
557 for (const auto & p : param_names)
558 available += (available.empty() ? "" : ", ") + p;
559 if (matches.size() > 1)
560 {
561 std::string m;
562 for (const auto & x : matches)
563 m += (m.empty() ? "" : ", ") + x;
564 mooseError("The NEML2 model parameter name '",
565 user_name,
566 "' is ambiguous; it matches multiple registered parameters: ",
567 m,
568 ". Use the fully-qualified name.");
569 }
570 mooseError("The NEML2 model parameter '",
571 user_name,
572 "' does not exist. Available model parameters: ",
573 available);
574}

Referenced by setupParameterDerivativeMappings(), and setupParameterMappings().

◆ setupDerivativeMappings()

void NEML2Action::setupDerivativeMappings ( const NEML2ModelHandle &  model)
protected

Set up MOOSE-NEML2 derivative mappings.

Definition at line 494 of file NEML2Action.C.

495{
496 const auto derivs = getParam<std::vector<std::vector<std::string>>>("derivatives");
497 const auto in_shapes = shapeMap(model.input_names(), model.input_base_shapes());
498 const auto out_shapes = shapeMap(model.output_names(), model.output_base_shapes());
499
500 for (auto i : index_range(derivs))
501 {
502 if (derivs[i].size() != 2 && derivs[i].size() != 3)
503 paramError("derivatives",
504 "Each entry in derivatives must have 2 elements (output, input) or 3 "
505 "(output, input, alias).");
506
507 const auto & y = derivs[i][0];
508 const auto & x = derivs[i][1];
509 if (!contains(model.output_names(), y))
510 paramError("derivatives", "The NEML2 output variable ", y, " does not exist.");
511 if (!contains(model.input_names(), x))
512 paramError("derivatives", "The NEML2 input variable ", x, " does not exist.");
513
514 // The derivative block's base shape is the concatenation of the output and input base shapes.
515 std::vector<int64_t> dshape = out_shapes.at(y);
516 const auto & xs = in_shapes.at(x);
517 dshape.insert(dshape.end(), xs.begin(), xs.end());
518 const auto mtype = shapeToMooseType(dshape);
519 if (mtype.empty())
520 mooseError("The NEML2 derivative of ",
521 y,
522 " with respect to ",
523 x,
524 " has a base shape not yet mapped to a MOOSE type.");
525
526 // An optional third element aliases the derivative to a custom material property name.
527 const MaterialPropertyName deriv_name = derivs[i].size() == 3
528 ? MaterialPropertyName(derivs[i][2])
530 _derivs.push_back({deriv_name, y, x, mtype});
531 }
532}
virtual const std::vector< std::string > & input_names() const =0
virtual const std::vector< std::vector< int64_t > > & output_base_shapes() const =0
virtual const std::vector< std::vector< int64_t > > & input_base_shapes() const =0

◆ setupInputMappings()

void NEML2Action::setupInputMappings ( const NEML2ModelHandle &  model)
protected

Set up MOOSE-NEML2 input variable mappings.

Definition at line 383 of file NEML2Action.C.

384{
385 const auto & kernels = getParam<std::vector<std::string>>("input_kernels");
386 const auto & explicit_inputs = getParam<std::vector<std::string>>("inputs");
387 const auto in_shapes = shapeMap(model.input_names(), model.input_base_shapes());
388
389 // Default mapping
390 for (const auto & vname : model.input_names())
391 {
392 const auto [base, order] = parseLag(vname);
393
394 // user requested to skip (by base name)
396 continue;
397
398 // skip if the input is directly provided by a custom kernel (matched by full NEML2 name)
399 if (contains(kernels, vname))
400 continue;
401
402 // skip stateful (old) inputs when managing state advance on the compute device
403 if (getParam<bool>("manage_state_advance") && order > 0)
404 continue;
405
406 // An order-0 input that is ALSO a model output is an in-place-updated unknown (e.g. an
407 // ImplicitUpdate initial guess that has no old counterpart). The default gatherer would read
408 // its own stale output material -- the previous converged step's value -- as the "current"
409 // initial guess, warm-starting a rate-like unknown from a value that can prevent the return-map
410 // Newton solve from converging. Unless the user maps it explicitly, cold-start it at zero: skip
411 // the gatherer here and let the executor seed a base-shaped zero (broadcast over the batch).
412 if (order == 0 && contains(model.output_names(), vname) && !contains(explicit_inputs, vname))
413 {
414 mooseInfo("NEML2 input '",
415 vname,
416 "' is also a model output (an in-place-updated unknown), so it is cold-started at "
417 "zero on every evaluation instead of gathered from its stale output material. To "
418 "supply an explicit initial guess instead, map it via 'inputs'/'moose_inputs'.");
419 continue;
420 }
421
422 const auto & base_shape = in_shapes.at(vname);
423 const auto mtype = shapeToMooseType(base_shape);
424 if (mtype.empty())
426 "NEML2 input variable ", vname, " has a base shape not yet mapped to a MOOSE type.");
427
428 _inputs.push_back(
429 {base, inferMOOSEIOType(base, base_shape.empty()), mtype, static_cast<std::size_t>(order)});
430 }
431
432 // User-specified mapping (overrides default mapping)
433 const auto [input_types, inputs] =
434 getInputParameterMapping<NEML2Utils::MOOSEIOType, std::string>("input_types", "inputs");
435
436 for (auto i : index_range(inputs))
437 {
438 const auto base_i = parseLag(inputs[i]).first;
439 // Check if the input variable also appears in skip_input_variables
441 paramError("skip_input_variables",
442 "The input variable ",
443 inputs[i],
444 " is listed in skip_input_variables, but it also appears in inputs. Please "
445 "remove it from either list.");
446 // Check if the input variable exists in the NEML2 model
447 if (!contains(model.input_names(), inputs[i]))
448 paramError("inputs", "The neml2 input variable ", inputs[i], " does not exist.");
449 // Check if the input variable is already gathered by a custom kernel
450 if (contains(kernels, inputs[i]))
451 paramError("inputs",
452 "The input variable ",
453 inputs[i],
454 " is listed in inputs, but it also appears in input_kernels. Please "
455 "remove it from either list.");
456 // Check if the input variable is stateful and manage_state_advance is true
457 if (getParam<bool>("manage_state_advance") && parseLag(inputs[i]).second > 0)
458 paramError("inputs",
459 "The input variable ",
460 inputs[i],
461 " is listed in inputs, but it is an old (stateful) variable and "
462 "manage_state_advance is true. Please remove it from inputs, or set "
463 "manage_state_advance to false.");
464
465 // Get the existing mapping for this neml2 input variable and override its MOOSE type
466 for (auto & input : _inputs)
467 if (input.name == base_i)
468 {
469 input.moose_type = input_types[i];
470 break;
471 }
472 }
473}
NEML2Utils::MOOSEIOType inferMOOSEIOType(const std::string &name, bool is_scalar) const
Infer the MOOSE IO type from the variable name (only scalar-typed variables can map to time/scalar/fu...
std::pair< std::string, int > parseLag(const std::string &name)
Parse NEML2 v3 lag notation: "var~N" is the N-th old value of a variable (var~1 == old var,...
Definition NEML2Utils.h:58

◆ setupOutputMappings()

void NEML2Action::setupOutputMappings ( const NEML2ModelHandle &  model)
protected

Set up MOOSE-NEML2 output variable mappings.

Definition at line 476 of file NEML2Action.C.

477{
478 if (!getParam<bool>("auto_output"))
479 return;
480
481 const auto out_shapes = shapeMap(model.output_names(), model.output_base_shapes());
482
483 for (const auto & oname : model.output_names())
484 {
485 const auto mtype = shapeToMooseType(out_shapes.at(oname));
486 if (mtype.empty())
488 "NEML2 output variable ", oname, " has a base shape not yet mapped to a MOOSE type.");
489 _outputs.push_back({oname, NEML2Utils::MOOSEIOType::MATERIAL, mtype, /*history_order=*/0});
490 }
491}

◆ setupParameterDerivativeMappings()

void NEML2Action::setupParameterDerivativeMappings ( const NEML2ModelHandle &  model)
protected

Set up MOOSE-NEML2 output-parameter-derivative mappings.

Definition at line 595 of file NEML2Action.C.

596{
597 const auto derivs = getParam<std::vector<std::vector<std::string>>>("parameter_derivatives");
598 const auto out_shapes = shapeMap(model.output_names(), model.output_base_shapes());
599 const auto & pshapes = model.parameter_base_shapes();
600
601 for (auto i : index_range(derivs))
602 {
603 if (derivs[i].size() != 2 && derivs[i].size() != 3)
604 paramError("parameter_derivatives",
605 "Each entry in parameter_derivatives must have 2 elements (output, parameter) "
606 "or 3 (output, parameter, alias).");
607
608 const auto & y = derivs[i][0];
609 const auto & x_user = derivs[i][1];
610 if (!contains(model.output_names(), y))
611 paramError("parameter_derivatives", "The NEML2 output variable ", y, " does not exist.");
612 const auto x = resolveParameterName(x_user, pshapes);
613
614 // The derivative block's base shape is the concatenation of the output and parameter base
615 // shapes.
616 std::vector<int64_t> dshape = out_shapes.at(y);
617 const auto & xs = pshapes.at(x);
618 dshape.insert(dshape.end(), xs.begin(), xs.end());
619 const auto mtype = shapeToMooseType(dshape);
620 if (mtype.empty())
621 mooseError("The NEML2 derivative of ",
622 y,
623 " with respect to model parameter ",
624 x,
625 " has a base shape not yet mapped to a MOOSE type.");
626
627 // By default the material-property name uses the user-written parameter name (the qualified
628 // name drives the NEML2-side parameter derivative); an optional third element aliases it.
629 const MaterialPropertyName deriv_name = derivs[i].size() == 3
630 ? MaterialPropertyName(derivs[i][2])
631 : derivativePropertyNameFirst(y, x_user);
632 _param_derivs.push_back({deriv_name, y, x, mtype});
633 }
634}
std::vector< DerivativeMapping > _param_derivs
MOOSE-NEML2 output-parameter-derivative mappings.
std::string resolveParameterName(const std::string &user_name, const std::map< std::string, std::vector< int64_t > > &param_shapes) const
Resolve a user-written parameter name to a fully-qualified NEML2 parameter name.
virtual const std::map< std::string, std::vector< int64_t > > & parameter_base_shapes() const =0

◆ setupParameterMappings()

void NEML2Action::setupParameterMappings ( const NEML2ModelHandle &  model)
protected

Set up MOOSE-NEML2 model parameter (value) mappings.

Definition at line 577 of file NEML2Action.C.

578{
579 const auto [param_types, params] = getInputParameterMapping<NEML2Utils::MOOSEIOType, std::string>(
580 "parameter_types", "parameters");
581 const auto & pshapes = model.parameter_base_shapes();
582
583 for (auto i : index_range(params))
584 {
585 const auto qn = resolveParameterName(params[i], pshapes);
586 const auto mtype = shapeToMooseType(pshapes.at(qn));
587 if (mtype.empty())
589 "The NEML2 model parameter ", qn, " has a base shape not yet mapped to a MOOSE type.");
590 _params.push_back({params[i], qn, param_types[i], mtype});
591 }
592}
std::vector< ParameterMapping > _params
MOOSE-NEML2 model parameter (value) mappings.

◆ specificTaskName()

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

Definition at line 110 of file Action.h.

110{ return _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 ",
89#endif
90 };
91
92 parallel_verify(true);
93
94 act();
95
96 parallel_verify(false);
97}
virtual void act()=0
Method to add objects to the simulation or perform other setup tasks.
const std::string & _current_task
The current action (even though we have separate instances for each action)
Definition Action.h:172
PerfID _act_timer
Timers.
Definition Action.h:181
std::string typeAndName() const
Get the class's combined type and name; useful in error handling.
Definition MooseBase.C:57

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() ? section_name : _prefix + "::" + section_name;
58}
const std::string _prefix
A prefix to use for all sections.

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 }
const std::string & _type
The type of this class.
Definition MooseBase.h:378

Referenced by CreateProblemDefaultAction::act(), MaterialOutputAction::act(), SetupDebugAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addConvergence(), MFEMProblem::addDefaultProblemComposer(), MFEMProblem::addDefaultWeakForm(), 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(), MFEMProblem::addObject(), FEProblemBase::addObject(), DistributedRectilinearMeshGenerator::addPoint(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addVectorPostprocessor(), SubProblem::addVectorTag(), DisplacedProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelBase::AuxKernelBase(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshGenerator::checkGetMesh(), 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(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), MeshGenerator::declareMeshProperty(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiAppTransfers(), SteadyBase::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), 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(), EqualValueBoundaryConstraint::ghostPrimary(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), TimeIntegrator::init(), 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(), MooseApp::MooseApp(), MooseObject::MooseObject(), SubProblem::numVectorTags(), DisplacedProblem::numVectorTags(), AdvancedOutput::output(), Console::output(), ConsoleUtils::outputExecutionInformation(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), PointInUnionCheckUO::PointInUnionCheckUO(), MooseMesh::prepare(), MFEMFunctorMaterial::processLiterals(), 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().

◆ 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}
static const std::string unique_name_param
The name of the parameter that contains the unique object name.
Definition MooseBase.h:57
A class for storing the names of MooseObject by tag and object name.

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}
const std::string & getBase() const
Definition MooseBase.h:147

◆ validParams()

InputParameters NEML2Action::validParams ( )
static

Definition at line 66 of file NEML2Action.C.

67{
69 params.addClassDescription("Set up the NEML2 material model");
70 params.addParam<std::string>("executor_name",
71 "Name of the NEML2ModelExecutor user object. The default name is "
72 "'neml2_<model-name>_<block-name>' where <model-name> is the NEML2 "
73 "model's name, and <block-name> is this action sub-block's name.");
74 params.addParam<std::string>(
75 "batch_index_generator_name",
76 "Name of the NEML2BatchIndexGenerator user object. The default name is "
77 "'neml2_index_<model-name>_<block-name>' where <model-name> is the NEML2 model's name, and "
78 "<block-name> is this action sub-block's name.");
79 params.addParam<std::vector<SubdomainName>>(
80 "block", {}, "List of blocks (subdomains) where the material model is defined");
81 return params;
82}
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system.
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.
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.
static InputParameters commonParams()
Parameters that can be specified EITHER under the common area OR under sub-blocks.

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

◆ _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(), BatchMeshGeneratorAction::addMeshGenerators(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), CheckOutputAction::checkConsoleOutput(), CheckOutputAction::checkMaterialOutput(), CheckOutputAction::checkPerfLogOutput(), CheckOutputAction::checkVariableOutput(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), NEML2Action(), PhysicsBase::prepareCopyVariablesFromMesh(), printSummary(), PhysicsBase::reportPotentiallyMissedParameters(), MeshGeneratorComponent::setupComponent(), SetupMeshAction::setupMesh(), and PhysicsBase::shouldCreateIC().

◆ _awh

ActionWarehouse& Action::_awh
protectedinherited

◆ _block

const std::vector<SubdomainName> NEML2Action::_block
protected

Blocks this sub-block action applies to.

Definition at line 134 of file NEML2Action.h.

◆ _cli_args

std::vector<std::string> NEML2Action::_cli_args
protected

List of cli-args.

Definition at line 105 of file NEML2Action.h.

Referenced by NEML2Action().

◆ _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::checkNonConformingFaces(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), 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(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), StitchMeshGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), 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(), NEML2Action(), 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(), DefaultMultiAppFixedPointConvergence::preLoop(), 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(), 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

◆ _derivs

std::vector<DerivativeMapping> NEML2Action::_derivs
protected

MOOSE-NEML2 derivative mappings.

Definition at line 118 of file NEML2Action.h.

Referenced by getLongestMOOSEName(), printSummary(), and setupDerivativeMappings().

◆ _displaced_mesh

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

Definition at line 175 of file Action.h.

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

◆ _executor_name

const UserObjectName NEML2Action::_executor_name
protected

Name of the NEML2Executor user object.

Definition at line 128 of file NEML2Action.h.

◆ _export_output_targets

std::map<MaterialPropertyName, std::vector<OutputName> > NEML2Action::_export_output_targets
protected

Material property additional outputs.

Definition at line 143 of file NEML2Action.h.

Referenced by NEML2Action().

◆ _factory

Factory& ParallelParamObject::_factory
protectedinherited

◆ _fname

FileName NEML2Action::_fname
protected

Name of the NEML2 input file.

Definition at line 102 of file NEML2Action.h.

Referenced by fname(), and NEML2Action().

◆ _idx_generator_name

const UserObjectName NEML2Action::_idx_generator_name
protected

Name of the NEML2BatchIndexGenerator user object.

Definition at line 131 of file NEML2Action.h.

◆ _initialize_output_values

std::map<MaterialPropertyName, MaterialPropertyName> NEML2Action::_initialize_output_values
protected

Material property initial conditions.

Definition at line 140 of file NEML2Action.h.

Referenced by checkStatefulConsistency(), and NEML2Action().

◆ _inputs

std::vector<VariableMapping> NEML2Action::_inputs
protected

MOOSE-NEML2 input variable mappings.

Definition at line 112 of file NEML2Action.h.

Referenced by checkStatefulConsistency(), getLongestMOOSEName(), printSummary(), and setupInputMappings().

◆ _mesh

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

◆ _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().

◆ _model

std::unique_ptr<NEML2ModelHandle> NEML2Action::_model
protected

The neml2 model handle, used here only for introspection during setup.

Built from the cpp-eager source '.i' or the cpp-aoti artifact folder – both given by 'input' – per 'eager'.

Definition at line 109 of file NEML2Action.h.

Referenced by NEML2Action(), and printSummary().

◆ _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(), AddFVGradientMethodAction::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(), AddMFEMProblemComposerAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), AddMFEMWeakFormAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::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().

◆ _outputs

std::vector<VariableMapping> NEML2Action::_outputs
protected

MOOSE-NEML2 output variable mappings.

Definition at line 115 of file NEML2Action.h.

Referenced by getLongestMOOSEName(), printSummary(), and setupOutputMappings().

◆ _param_derivs

std::vector<DerivativeMapping> NEML2Action::_param_derivs
protected

MOOSE-NEML2 output-parameter-derivative mappings.

Definition at line 124 of file NEML2Action.h.

Referenced by setupParameterDerivativeMappings().

◆ _params

std::vector<ParameterMapping> NEML2Action::_params
protected

MOOSE-NEML2 model parameter (value) mappings.

Definition at line 121 of file NEML2Action.h.

Referenced by setupParameterMappings().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent
privateinherited

◆ _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(), 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(), MooseApp::MooseApp(), 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(), AddFVGradientMethodAction::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(), MaterialOutputAction::act(), PhysicsVariableCoordinator::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(), AddMFEMProblemComposerAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), AddMFEMWeakFormAction::act(), ResolveMFEMSolversAction::act(), SetMFEMEquationSystemsAction::act(), SetMFEMMeshFESpaceAction::act(), SetMFEMProblemOperatorsAction::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(), 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

◆ _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().

◆ _skip_input_variables

std::vector<std::string> NEML2Action::_skip_input_variables
protected

Input variables to skip (i.e., not to set up mappings for)

Definition at line 137 of file NEML2Action.h.

Referenced by setupInputMappings().

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

◆ app_param

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

◆ 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

◆ 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

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