PhysicsComponentInterface Class Reference

Interface class to help components interact with Physics. More...

#include <PhysicsComponentInterface.h>

Inheritance diagram for PhysicsComponentInterface:

Public Types
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name. More...

Public Member Functions
	PhysicsComponentInterface (const InputParameters &parameters)
virtual void	addComponent (const ActionComponent &component) override
	Adds various info from the component. More...
void	addInitialCondition (const ComponentName &component_name, const VariableName &var_name, const MooseFunctorName &ic_value)
	Add an initial condition from a component. More...
void	addBoundaryCondition (const ComponentName &component_name, const VariableName &var_name, const BoundaryName &boundary_name, const MooseFunctorName &bc_value, const ComponentBoundaryConditionInterface::BoundaryConditionType &bc_type)
	Add a boundary condition from a component. More...
virtual InputParameters	getAdditionalRMParams () const
	Provide additional parameters for the relationship managers. More...
virtual void	act () override final
	Forwards from the action tasks to the implemented addXYZ() in the derived classes If you need more than these: More...
void	addBlocks (const std::vector< SubdomainName > &blocks)
	Add new blocks to the Physics. More...
void	addBlocksById (const std::vector< SubdomainID > &block_ids)
const std::vector< SubdomainName > &	blocks () const
	Return the blocks this physics is defined on. More...
bool	checkBlockRestrictionIdentical (const std::string &object_name, const std::vector< SubdomainName > &blocks, const bool error_if_not_identical=true) const
	Check if an external object has the same block restriction. More...
template<typename T >
const T *	getCoupledPhysics (const PhysicsName &phys_name, const bool allow_fail=false) const
	Get a Physics from the ActionWarehouse with the requested type and name. More...
template<typename T >
const std::vector< T * >	getCoupledPhysics (const bool allow_fail=false) const
	Get all Physics from the ActionWarehouse with the requested type. More...
unsigned int	dimension () const
	Return the maximum dimension of the blocks the Physics is active on. More...
const ActionComponent &	getActionComponent (const ComponentName &comp_name) const
	Get a component with the requested name. More...
template<typename T >
void	checkComponentType (const ActionComponent &component) const
	Check that the component is of the desired type. More...
const std::vector< VariableName > &	solverVariableNames () const
	Return the list of solver (nonlinear + linear) variables in this physics. More...
const std::vector< VariableName > &	auxVariableNames () const
	Return the list of aux variables in this physics. More...
void	timedAct ()
	The method called externally that causes the action to act() More...
MooseObjectName	uniqueActionName () const
	The unique name for accessing input parameters of this action in the InputParameterWarehouse. More...
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. More...
const std::string &	type () const
	Get the type of this class. More...
const std::string &	name () const
	Get the name of the class. More...
std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
	Get the parameters of the object. More...
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. More...
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. More...
template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object. More...
template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object. More...
template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller. More...
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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(). More...
template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning(). More...
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
	External method for calling moose error with added object context. More...
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. More...
std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method. More...
std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path. More...
PerfGraph &	perfGraph ()
	Get the PerfGraph. More...
void	assertParamDefined (const std::string &libmesh_dbg_var(param)) const

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

Public Attributes
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects. More...

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. More...
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type. More...
static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name. More...
static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name. More...
static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp. More...
static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base. More...
static constexpr auto	SYSTEM = "MeshMetaData"
	The system name used when initializing the Restartable interface. More...
static constexpr auto	NAME = "<empty>"
	The data name used when initializing the Restartable interface for non-MeshGenerator objects. More...

Protected Member Functions
bool	isTransient () const
	Return whether the Physics is solved using a transient. More...
Factory &	getFactory ()
	Get the factory for this physics The factory lets you get the parameters for objects. More...
Factory &	getFactory () const
virtual FEProblemBase &	getProblem ()
	Get the problem for this physics Useful to add objects to the simulation. More...
virtual const FEProblemBase &	getProblem () const
void	prepareCopyVariablesFromMesh () const
	Tell the app if we want to use Exodus restart. More...
void	copyVariablesFromMesh (const std::vector< VariableName > &variables_to_copy, bool are_nonlinear=true)
	Copy nonlinear or aux variables from the mesh file. More...
std::string	prefix () const
	Use prefix() to disambiguate names. More...
void	saveSolverVariableName (const VariableName &var_name)
	Keep track of the name of the solver variable defined in the Physics. More...
void	saveAuxVariableName (const VariableName &var_name)
	Keep track of the name of an aux variable defined in the Physics. More...
bool	variableExists (const VariableName &var_name, bool error_if_aux) const
	Check whether a variable already exists. More...
bool	solverVariableExists (const VariableName &var_name) const
	Check whether a variable already exists and is a solver variable. More...
const SolverSystemName &	getSolverSystem (unsigned int variable_index) const
	Get the solver system for this variable index. More...
const SolverSystemName &	getSolverSystem (const VariableName &variable_name) const
	Get the solver system for this variable name. More...
void	addRequiredPhysicsTask (const std::string &task)
	Add a new required task for all physics deriving from this class NOTE: This does not register the task, you still need to call registerMooseAction. More...
void	assignBlocks (InputParameters &params, const std::vector< SubdomainName > &blocks) const
	Set the blocks parameter to the input parameters of an object this Physics will create. More...
bool	allMeshBlocks (const std::vector< SubdomainName > &blocks) const
	Check if a vector contains all the mesh blocks. More...
bool	allMeshBlocks (const std::set< SubdomainName > &blocks) const
std::set< SubdomainID >	getSubdomainIDs (const std::set< SubdomainName > &blocks) const
	Get the set of subdomain ids for the incoming vector of subdomain names. More...
std::vector< std::string >	getSubdomainNamesAndIDs (const std::set< SubdomainID > &blocks) const
	Get the vector of subdomain names and ids for the incoming set of subdomain IDs. More...
void	addPetscPairsToPetscOptions (const std::vector< std::pair< MooseEnumItem, std::string >> &petsc_pair_options)
	Process the given petsc option pairs into the system solver settings. More...
bool	isVariableFV (const VariableName &var_name) const
	Whether the variable is a finite volume variable. More...
bool	isVariableScalar (const VariableName &var_name) const
	Whether the variable is a scalar variable (global single scalar, not a field) More...
bool	shouldCreateVariable (const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_aux)
	Returns whether this Physics should create the variable. More...
bool	shouldCreateIC (const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool ic_is_default_ic, const bool error_if_already_defined) const
	Returns whether this Physics should create the variable. More...
bool	shouldCreateTimeDerivative (const VariableName &var_name, const std::vector< SubdomainName > &blocks, const bool error_if_already_defined) const
	Returns whether this Physics should create the variable. More...
void	reportPotentiallyMissedParameters (const std::vector< std::string > &param_names, const std::string &object_type) const
	When this is called, we are knowingly not using the value of these parameters. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
std::string	timedSectionName (const std::string &section_name) const
void	assertParamDefined (const std::string &param) const
	Check in debug mode that this parameter has been added to the validParams. More...
void	checkParamsBothSetOrNotSet (const std::string &param1, const std::string &param2) const
	Check that two parameters are either both set or both not set. More...
void	checkSecondParamSetOnlyIfFirstOneTrue (const std::string &param1, const std::string &param2) const
	Check that a parameter is set only if the first one is set to true. More...
void	checkSecondParamSetOnlyIfFirstOneSet (const std::string &param1, const std::string &param2) const
	Check that a parameter is set only if the first one is set. More...
void	checkSecondParamNotSetIfFirstOneSet (const std::string &param1, const std::string &param2) const
	Check that a parameter is not set if the first one is set. More...
void	checkVectorParamsSameLength (const std::string &param1, const std::string &param2) const
	Check that the two vector parameters are of the same length. More...
void	checkVectorParamAndMultiMooseEnumLength (const std::string &param1, const std::string &param2) const
	Check that this vector parameter (with name defined in param1) has the same length as the MultiMooseEnum (with name defined in param2) More...
void	checkTwoDVectorParamsSameLength (const std::string &param1, const std::string &param2) const
	Check that the two-D vectors have exactly the same length in both dimensions. More...
void	checkVectorParamsNoOverlap (const std::vector< std::string > &param_vecs) const
	Check that there is no overlap between the items in each vector parameters Each vector parameter should also have unique items. More...
void	checkTwoDVectorParamsNoRespectiveOverlap (const std::vector< std::string > &param_vecs) const
	Check that there is no overlap between the respective items in each vector of the two-D parameters Each vector of the two-D vector parameter should also have unique items. More...
void	checkTwoDVectorParamInnerSameLengthAsOneDVector (const std::string &param1, const std::string &param2) const
	Check that each inner vector of a two-D vector parameter are the same size as another one-D vector parameter. More...
void	checkTwoDVectorParamMultiMooseEnumSameLength (const std::string &param1, const std::string &param2, const bool error_for_param2) const
	Check that the size of a two-D vector parameter matches the size of a MultiMooseEnum parameter. More...
void	checkVectorParamNotEmpty (const std::string &param1) const
	Check that the user did not pass an empty vector. More...
void	checkVectorParamsSameLengthIfSet (const std::string &param1, const std::string &param2, const bool ignore_empty_default_param2=false) const
	Check that two vector parameters are the same length if both are set. More...
void	checkVectorParamLengthSameAsCombinedOthers (const std::string &param1, const std::string &param2, const std::string &param3) const
	Check that a vector parameter is the same length as two others combined. More...
void	checkBlockwiseConsistency (const std::string &block_param_name, const std::vector< std::string > &parameter_names) const
	Check if the user commited errors during the definition of block-wise parameters. More...
bool	parameterConsistent (const InputParameters &other_param, const std::string &param_name) const
	Return whether two parameters are consistent. More...
void	warnInconsistent (const InputParameters &parameters, const std::string &param_name) const
	Emits a warning if two parameters are not equal to each other. More...
void	errorDependentParameter (const std::string &param1, const std::string &value_not_set, const std::vector< std::string > &dependent_params) const
	Error messages for parameters that should depend on another parameter. More...
void	errorInconsistentDependentParameter (const std::string &param1, const std::string &value_set, const std::vector< std::string > &dependent_params) const
	Error messages for parameters that should depend on another parameter but with a different error message. More...

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::map< std::string, std::map< VariableName, MooseFunctorName > >	_components_initial_conditions
	Map of components to variables and initial conditions. More...
std::map< std::string, std::map< std::pair< VariableName, BoundaryName >, std::pair< MooseFunctorName, ComponentBoundaryConditionInterface::BoundaryConditionType > > >	_components_boundary_conditions
	Map of components to variables and boundary conditions. More...
std::vector< SolverSystemName >	_system_names
	System names for the system(s) owning the solver variables. More...
std::vector< unsigned int >	_system_numbers
	System numbers for the system(s) owning the solver variables. More...
const bool	_verbose
	Whether to output additional information. More...
const MooseEnum &	_preconditioning
	Whether to add a default preconditioning. More...
std::vector< SubdomainName >	_blocks
	Keep track of the subdomains the Physics is defined on. More...
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. More...
std::set< std::string >	_all_tasks
	A list of all the tasks that this Action will satisfy. More...
ActionWarehouse &	_awh
	Reference to ActionWarehouse where we store object build by actions. More...
const std::string &	_current_task
	The current action (even though we have separate instances for each action) More...
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. More...
PerfID	_act_timer
	Timers. More...
MooseApp &	_app
	The MOOSE application this is associated with. More...
Factory &	_factory
	The Factory associated with the MooseApp. More...
ActionFactory &	_action_factory
	Builds Actions. More...
const std::string &	_type
	The type of this class. More...
const std::string &	_name
	The name of this class. More...
const InputParameters &	_pars
	The object's parameters. More...
const Parallel::Communicator &	_communicator
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...
const std::string	_prefix
	A prefix to use for all sections. More...

Private Member Functions
virtual void	actOnAdditionalTasks () override
	Routine to add additional setup work on additional registered tasks to a Physics. More...
virtual void	addInitialConditionsFromComponents ()
virtual void	addBoundaryConditionsFromComponents ()

Detailed Description

Interface class to help components interact with Physics.

Definition at line 19 of file PhysicsComponentInterface.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.

Constructor & Destructor Documentation

PhysicsComponentInterface()

PhysicsComponentInterface::PhysicsComponentInterface

(

const InputParameters &

parameters

)

Definition at line 21 of file PhysicsComponentInterface.C.

  : PhysicsBase(parameters)
{
  addRequiredPhysicsTask("add_ic");
}

Member Function Documentation

act()

void PhysicsBase::act ( )

finaloverridevirtualinherited

Forwards from the action tasks to the implemented addXYZ() in the derived classes If you need more than these:

• register your action to the new task using registerMooseAction("AppName", ActionClass, "task_name");
• override actOnAdditionalTasks and add your additional work there

Implements Action.

Definition at line 121 of file PhysicsBase.C.

{
  mooseDoOnce(checkRequiredTasks());

  // Lets a derived Physics class implement additional tasks
  actOnAdditionalTasks();

  // Initialization and variables
  if (_current_task == "init_physics")
    initializePhysics();
  else if (_current_task == "add_variable" && !getParam<bool>("dont_create_solver_variables"))
    addSolverVariables();
  else if (_current_task == "add_ic" && !getParam<bool>("dont_create_ics"))
    addInitialConditions();

  // Kernels
  else if (_current_task == "add_kernel" && !getParam<bool>("dont_create_kernels"))
    addFEKernels();
  else if (_current_task == "add_nodal_kernel" && !getParam<bool>("dont_create_kernels"))
    addNodalKernels();
  else if ((_current_task == "add_fv_kernel" || _current_task == "add_linear_fv_kernel") &&
           !getParam<bool>("dont_create_kernels"))
    addFVKernels();
  else if (_current_task == "add_dirac_kernel" && !getParam<bool>("dont_create_kernels"))
    addDiracKernels();
  else if (_current_task == "add_dg_kernel" && !getParam<bool>("dont_create_kernels"))
    addDGKernels();
  else if (_current_task == "add_scalar_kernel" && !getParam<bool>("dont_create_kernels"))
    addScalarKernels();
  else if (_current_task == "add_interface_kernel" && !getParam<bool>("dont_create_kernels"))
    addInterfaceKernels();
  else if (_current_task == "add_fv_ik" && !getParam<bool>("dont_create_kernels"))
    addFVInterfaceKernels();

  // Boundary conditions
  else if (_current_task == "add_bc" && !getParam<bool>("dont_create_bcs"))
    addFEBCs();
  else if (_current_task == "add_nodal_bc" && !getParam<bool>("dont_create_bcs"))
    addNodalBCs();
  else if ((_current_task == "add_fv_bc" || _current_task == "add_linear_fv_bc") &&
           !getParam<bool>("dont_create_bcs"))
    addFVBCs();
  else if (_current_task == "add_periodic_bc" && !getParam<bool>("dont_create_bcs"))
    addPeriodicBCs();

  // Auxiliary quantities
  else if (_current_task == "add_function" && !getParam<bool>("dont_create_functions"))
    addFunctions();
  else if (_current_task == "add_aux_variable" && !getParam<bool>("dont_create_aux_variables"))
    addAuxiliaryVariables();
  else if (_current_task == "add_aux_kernel" && !getParam<bool>("dont_create_aux_kernels"))
    addAuxiliaryKernels();
  else if (_current_task == "add_material" && !getParam<bool>("dont_create_materials"))
    addMaterials();
  else if (_current_task == "add_functor_material" && !getParam<bool>("dont_create_materials"))
    addFunctorMaterials();

  // Multiapp
  else if (_current_task == "add_multi_app")
    addMultiApps();
  else if (_current_task == "add_transfer")
    addTransfers();

  // User objects and output
  else if (_current_task == "add_user_object" && !getParam<bool>("dont_create_user_objects"))
    addUserObjects();
  else if (_current_task == "add_corrector" && !getParam<bool>("dont_create_correctors"))
    addCorrectors();
  else if (_current_task == "add_postprocessor" && !getParam<bool>("dont_create_postprocessors"))
    addPostprocessors();
  else if (_current_task == "add_vector_postprocessor" &&
           !getParam<bool>("dont_create_vectorpostprocessors"))
    addVectorPostprocessors();
  else if (_current_task == "add_reporter")
    addReporters();
  else if (_current_task == "add_output")
    addOutputs();

  // Equation solver-related tasks
  else if (_current_task == "add_preconditioning")
    addPreconditioning();
  else if (_current_task == "add_executioner")
    addExecutioner();
  else if (_current_task == "add_executor")
    addExecutors();

  // Checks
  else if (_current_task == "check_integrity_early_physics")
    checkIntegrityEarly();
  else if (_current_task == "check_integrity")
    checkIntegrity();

  // Exodus restart capabilities
  if (_current_task == "copy_vars_physics")
  {
    copyVariablesFromMesh(solverVariableNames(), true);
    if (_aux_var_names.size() > 0)
      copyVariablesFromMesh(auxVariableNames(), false);
  }
}

actOnAdditionalTasks()

void PhysicsComponentInterface::actOnAdditionalTasks ( )

overrideprivatevirtual

Routine to add additional setup work on additional registered tasks to a Physics.

Reimplemented from PhysicsBase.

Definition at line 28 of file PhysicsComponentInterface.C.

{
  // TODO: find a way to force this routine to be called by derived classes
  if (_current_task == "add_ic")
    addInitialConditionsFromComponents();
  else if (_current_task == "add_bc" || _current_task == "add_fv_bc")
    addBoundaryConditionsFromComponents();
}

addBlocks()

void PhysicsBase::addBlocks ( const std::vector< SubdomainName > &  blocks )

inherited

Add new blocks to the Physics.

Parameters

blocks

list of blocks to add to the physics

Definition at line 283 of file PhysicsBase.C.

{
  if (blocks.size())
  {
    _blocks.insert(_blocks.end(), blocks.begin(), blocks.end());
    _dim = _mesh->getBlocksMaxDimension(_blocks);
  }
}

addBlocksById()

void PhysicsBase::addBlocksById ( const std::vector< SubdomainID > &  block_ids )

inherited

Definition at line 293 of file PhysicsBase.C.

{
  if (block_ids.size())
  {
    for (const auto bid : block_ids)
      _blocks.push_back(_mesh->getSubdomainName(bid));
    _dim = _mesh->getBlocksMaxDimension(_blocks);
  }
}

addBoundaryCondition()

void PhysicsComponentInterface::addBoundaryCondition	(	const ComponentName &	component_name,
		const VariableName &	var_name,
		const BoundaryName &	boundary_name,
		const MooseFunctorName &	bc_value,
		const ComponentBoundaryConditionInterface::BoundaryConditionType &	bc_type
	)

Add a boundary condition from a component.

Parameters

component_name	the name of the component with the boundary condition
var_name	the variable to provide the initial condition
boundary_name	the name of the boundary condition
bc_value	the functor providing the boundary condition
bc_type	the type of the boundary condition, defined in ComponentBoundaryConditionInterface at the moment

Definition at line 87 of file PhysicsComponentInterface.C.

Referenced by addComponent().

{
  _components_boundary_conditions[component_name][std::make_pair(var_name, boundary_name)] =
      std::make_pair(bc_value, bc_type);
}

addBoundaryConditionsFromComponents()

void PhysicsComponentInterface::addBoundaryConditionsFromComponents ( )

privatevirtual

Reimplemented in DiffusionCG.

Definition at line 115 of file PhysicsComponentInterface.C.

Referenced by actOnAdditionalTasks().

{
  if (_components_boundary_conditions.size())
  {
    std::vector<ComponentName> all_components(_components_boundary_conditions.size());
    for (const auto & comp : _components_boundary_conditions)
      all_components.push_back(comp.first);
    mooseError("Component(s) '",
               Moose::stringify(all_components),
               "' requested to add boundary conditions for the variable of this Physics. This "
               "Physics however does not implement the 'addBoundaryConditionsFromComponents' "
               "routine, so it cannot create these boundary conditions");
  }
}

addComponent()

void PhysicsComponentInterface::addComponent ( const ActionComponent &  component )

overridevirtual

Adds various info from the component.

• subdomains (from PhysicsBase::addComponent)
• initial conditions

Reimplemented from PhysicsBase.

Definition at line 38 of file PhysicsComponentInterface.C.

{
  // Adds the component's blocks to the block restriction at least
  PhysicsBase::addComponent(comp);

  // Move initial conditions from components to the Physics
  if (const auto comp_ic = dynamic_cast<const ComponentInitialConditionInterface *>(&comp))
  {
    for (const auto & var_name : solverVariableNames())
      if (comp_ic->hasInitialCondition(var_name))
        addInitialCondition(comp.name(), var_name, comp_ic->getInitialCondition(var_name, name()));
    for (const auto & var_name : auxVariableNames())
      if (comp_ic->hasInitialCondition(var_name))
        addInitialCondition(comp.name(), var_name, comp_ic->getInitialCondition(var_name, name()));
  }

  // Move boundary conditions from components to the Physics
  if (const auto comp_bc = dynamic_cast<const ComponentBoundaryConditionInterface *>(&comp))
  {
    for (const auto & var_name : solverVariableNames())
      if (comp_bc->hasBoundaryCondition(var_name))
        for (const auto & boundary : comp_bc->getBoundaryConditionBoundaries(var_name))
        {
          ComponentBoundaryConditionInterface::BoundaryConditionType bc_type;
          const auto boundary_functor =
              comp_bc->getBoundaryCondition(var_name, boundary, name(), bc_type);
          addBoundaryCondition(comp.name(), var_name, boundary, boundary_functor, bc_type);
        }
    for (const auto & var_name : auxVariableNames())
      if (comp_bc->hasBoundaryCondition(var_name))
        for (const auto & boundary : comp_bc->getBoundaryConditionBoundaries(var_name))
        {
          ComponentBoundaryConditionInterface::BoundaryConditionType bc_type;
          const auto boundary_functor =
              comp_bc->getBoundaryCondition(var_name, boundary, name(), bc_type);
          addBoundaryCondition(comp.name(), var_name, boundary, boundary_functor, bc_type);
        }
  }
}

addInitialCondition()

void PhysicsComponentInterface::addInitialCondition	(	const ComponentName &	component_name,
		const VariableName &	var_name,
		const MooseFunctorName &	ic_value
	)

Add an initial condition from a component.

Parameters

component_name	the name of the component to set the variable IC on
var_name	the variable to provide the initial condition
ic_value	the functor providing the initial condition

Definition at line 79 of file PhysicsComponentInterface.C.

Referenced by addComponent().

{
  _components_initial_conditions[component_name][var_name] = ic_value;
}

addInitialConditionsFromComponents()

void PhysicsComponentInterface::addInitialConditionsFromComponents ( )

privatevirtual

Reimplemented in DiffusionPhysicsBase.

Definition at line 99 of file PhysicsComponentInterface.C.

Referenced by actOnAdditionalTasks().

{
  if (_components_initial_conditions.size())
  {
    std::vector<ComponentName> all_components(_components_initial_conditions.size());
    for (const auto & comp : _components_initial_conditions)
      all_components.push_back(comp.first);
    mooseError("Component(s) '",
               Moose::stringify(all_components),
               "' requested to add the following initial conditions for this Physics. This Physics "
               "however does not implement the 'addInitialConditionsFromComponents' "
               "routine, so it cannot create these initial conditions");
  }
}

addPetscPairsToPetscOptions()

void PhysicsBase::addPetscPairsToPetscOptions ( const std::vector< std::pair< MooseEnumItem, std::string >> &  petsc_pair_options )

protectedinherited

Process the given petsc option pairs into the system solver settings.

Definition at line 575 of file PhysicsBase.C.

Referenced by DiffusionPhysicsBase::addPreconditioning().

{
  Moose::PetscSupport::PetscOptions & po = _problem->getPetscOptions();
  for (const auto solver_sys_num : _system_numbers)
    Moose::PetscSupport::addPetscPairsToPetscOptions(
        petsc_pair_options,
        _problem->mesh().dimension(),
        _problem->getSolverSystem(solver_sys_num).prefix(),
        *this,
        po);
}

addRelationshipManagers()

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_type	The 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_pars	The MooseObject to inspect for RelationshipManagers to add

Returns

Whether a relationship manager was added

Definition at line 130 of file Action.C.

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

{
  const auto & buildable_types = moose_object_pars.getBuildableRelationshipManagerTypes();

  bool added = false;

  for (const auto & buildable_type : buildable_types)
  {
    auto & rm_name = std::get<0>(buildable_type);
    auto & rm_type = std::get<1>(buildable_type);
    auto rm_input_parameter_func = std::get<2>(buildable_type);

    added = addRelationshipManager(
                input_rm_type, moose_object_pars, rm_name, rm_type, rm_input_parameter_func) ||
            added;
  }

  return added;
}

addRequiredPhysicsTask()

void PhysicsBase::addRequiredPhysicsTask ( const std::string &  task )

inlineprotectedinherited

Add a new required task for all physics deriving from this class NOTE: This does not register the task, you still need to call registerMooseAction.

Definition at line 158 of file PhysicsBase.h.

Referenced by DiffusionPhysicsBase::DiffusionPhysicsBase(), PhysicsBase::PhysicsBase(), and PhysicsComponentInterface().

{ _required_tasks.insert(task); }

allMeshBlocks() [1/2]

bool PhysicsBase::allMeshBlocks ( const std::vector< SubdomainName > &  blocks ) const

protectedinherited

Check if a vector contains all the mesh blocks.

Parameters

blocks

the vector blocks to check for whether it contains every block in the mesh

Definition at line 544 of file PhysicsBase.C.

Referenced by PhysicsBase::allMeshBlocks(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::getSubdomainIDs(), and PhysicsBase::shouldCreateVariable().

{
  mooseAssert(_mesh, "The mesh should exist already");
  // Try to return faster without examining every single block
  if (std::find(blocks.begin(), blocks.end(), "ANY_BLOCK_ID") != blocks.end())
    return true;
  else if (blocks.size() != _mesh->meshSubdomains().size())
    return false;

  for (const auto mesh_block : _mesh->meshSubdomains())
  {
    const auto & subdomain_name = _mesh->getSubdomainName(mesh_block);
    // Check subdomain name
    if (!subdomain_name.empty() &&
        std::find(blocks.begin(), blocks.end(), subdomain_name) == blocks.end())
      return false;
    // no subdomain name, check the IDs being used as names instead
    else if (std::find(blocks.begin(), blocks.end(), std::to_string(mesh_block)) == blocks.end())
      return false;
  }
  return true;
}

allMeshBlocks() [2/2]

bool PhysicsBase::allMeshBlocks ( const std::set< SubdomainName > &  blocks ) const

protectedinherited

Definition at line 568 of file PhysicsBase.C.

{
  std::vector<SubdomainName> blocks_vec(blocks.begin(), blocks.end());
  return allMeshBlocks(blocks_vec);
}

appendTask()

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

inlineinherited

Definition at line 107 of file Action.h.

{ _all_tasks.insert(task); }

assertParamDefined() [1/2]

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

protectedinherited

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

Parameters

param

parameter that should be defined

assertParamDefined() [2/2]

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

inherited

Definition at line 206 of file InputParametersChecksUtils.h.

{
  mooseAssert(forwardParameters().template have_parameter<T>(param),
              "Parameter '" + param + "' is not defined with type '" +
                  MooseUtils::prettyCppType<T>() + "' in object type '" +
                  MooseUtils::prettyCppType(forwardType()) + "'. Check your code.");
}

assignBlocks()

void PhysicsBase::assignBlocks ( InputParameters &  params, const std::vector< SubdomainName > &  blocks  ) const

protectedinherited

Set the blocks parameter to the input parameters of an object this Physics will create.

Parameters

params	the parameters of the object
blocks	the blocks to set as the parameter

Definition at line 484 of file PhysicsBase.C.

Referenced by DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), DiffusionPhysicsBase::addInitialConditionsFromComponents(), DiffusionFV::addSolverVariables(), and DiffusionCG::addSolverVariables().

{
  // We only set the blocks if we don't have `ANY_BLOCK_ID` defined because the subproblem
  // (through the mesh) errors out if we use this keyword during the addVariable/Kernel
  // functions
  if (std::find(blocks.begin(), blocks.end(), "ANY_BLOCK_ID") == blocks.end())
    params.set<std::vector<SubdomainName>>("block") = blocks;
  if (blocks.empty())
    mooseInfoRepeated("Empty block restriction assigned to an object created by Physics '" +
                      name() + "'.\n Did you mean to do this?");
}

associateWithParameter() [1/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 152 of file Action.C.

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

{
  associateWithParameter(parameters(), param_name, params);
}

associateWithParameter() [2/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 158 of file Action.C.

{
  const auto to_hit_node = params.getHitNode();
  if (!to_hit_node || to_hit_node->isRoot())
  {
    if (const auto hit_node = from_params.getHitNode(param_name))
      params.setHitNode(*hit_node, {});
    else if (const auto hit_node = from_params.getHitNode())
      params.setHitNode(*hit_node, {});
  }
}

auxVariableNames()

const std::vector<VariableName>& PhysicsBase::auxVariableNames ( ) const

inlineinherited

Return the list of aux variables in this physics.

Definition at line 100 of file PhysicsBase.h.

Referenced by PhysicsBase::act(), and addComponent().

{ return _aux_var_names; };

blocks()

const std::vector<SubdomainName>& PhysicsBase::blocks ( ) const

inlineinherited

Return the blocks this physics is defined on.

Definition at line 60 of file PhysicsBase.h.

Referenced by PhysicsBase::addBlocks(), DiffusionPhysicsBase::addInitialConditionsFromComponents(), PhysicsBase::allMeshBlocks(), PhysicsBase::assignBlocks(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::getSubdomainIDs(), PhysicsBase::getSubdomainNamesAndIDs(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), and PhysicsBase::shouldCreateVariable().

{ return _blocks; }

callMooseError() [1/2]

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

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix

Definition at line 102 of file MooseBase.C.

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

{
  callMooseError(&_app, _pars, msg, with_prefix, node);
}

callMooseError() [2/2]

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

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

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix

Definition at line 110 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);

  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }

  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;

  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node);
}

checkBlockRestrictionIdentical()

bool PhysicsBase::checkBlockRestrictionIdentical ( const std::string &  object_name, const std::vector< SubdomainName > &  blocks, const bool  error_if_not_identical = true  ) const

inherited

Check if an external object has the same block restriction.

Parameters

object_name	name of the object to check the block restriction of
blocks	the blocks for this object
error_if_not_identical	whether to error if the block restrictions dont match

Definition at line 497 of file PhysicsBase.C.

{
  // If identical, we can return fast
  if (_blocks == blocks)
    return true;
  // If one is block restricted to anywhere and the other is block restricted to anywhere manually
  if ((std::find(_blocks.begin(), _blocks.end(), "ANY_BLOCK_ID") != _blocks.end() &&
       allMeshBlocks(blocks)) ||
      (std::find(blocks.begin(), blocks.end(), "ANY_BLOCK_ID") != blocks.end() &&
       allMeshBlocks(_blocks)))
    return true;

  // Copy, sort and unique is the only way to check that they are actually the same
  auto copy_blocks = _blocks;
  auto copy_blocks_other = blocks;
  std::sort(copy_blocks.begin(), copy_blocks.end());
  copy_blocks.erase(unique(copy_blocks.begin(), copy_blocks.end()), copy_blocks.end());
  std::sort(copy_blocks_other.begin(), copy_blocks_other.end());
  copy_blocks_other.erase(unique(copy_blocks_other.begin(), copy_blocks_other.end()),
                          copy_blocks_other.end());

  if (copy_blocks == copy_blocks_other)
    return true;
  std::vector<SubdomainName> diff;
  std::set_difference(copy_blocks.begin(),
                      copy_blocks.end(),
                      copy_blocks_other.begin(),
                      copy_blocks_other.end(),
                      std::inserter(diff, diff.begin()));
  if (error_if_not_identical)
    mooseError("Physics '",
               name(),
               "' and object '",
               object_name,
               "' have different block restrictions.\nPhysics: ",
               Moose::stringify(_blocks),
               "\nObject: ",
               Moose::stringify(blocks),
               "\nDifference: ",
               Moose::stringify(diff));
  else
    return false;
}

checkBlockwiseConsistency()

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

protectedinherited

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

Parameters

block_param_name	the name of the parameter that provides the groups of blocks
parameter_names	vector of the names of the parameters that are defined on a per-block basis

Definition at line 483 of file InputParametersChecksUtils.h.

{
  const std::vector<std::vector<SubdomainName>> & block_names =
      forwardGetParam<std::vector<std::vector<SubdomainName>>>(block_param_name);

  if (block_names.size())
  {
    // We only check block-restrictions if the customer class is not restricted to `ANY_BLOCK_ID`.
    // If the users define blocks that are not on the mesh, they will receive errors from the
    // objects created by the customer class
    const auto & object_blocks = forwardBlocks();
    if (std::find(object_blocks.begin(), object_blocks.end(), "ANY_BLOCK_ID") ==
        object_blocks.end())
      for (const auto & block_group : block_names)
        for (const auto & block : block_group)
          if (std::find(object_blocks.begin(), object_blocks.end(), block) == object_blocks.end())
            forwardParamError(block_param_name,
                              "Block '" + block + "' is not present in the block restriction of " +
                                  forwardName() +
                                  "!\nBlock restriction: " + Moose::stringify(object_blocks));

    for (const auto & param_name : parameter_names)
    {
      const std::vector<T> & param_vector = forwardGetParam<std::vector<T>>(param_name);
      if (block_names.size() != param_vector.size())
        forwardParamError(param_name,
                          "The number of entries in '" + param_name + "' (" +
                              std::to_string(param_vector.size()) +
                              ") is not the same as the number of blocks"
                              " (" +
                              std::to_string(block_names.size()) + ") in '" + block_param_name +
                              "'!");
    }
  }
  else
  {
    unsigned int previous_size = 0;
    for (const auto param_i : index_range(parameter_names))
    {
      const std::vector<T> & param_vector =
          forwardGetParam<std::vector<T>>(parameter_names[param_i]);
      if (param_i == 0)
      {
        if (param_vector.size() > 1)
          forwardParamError(parameter_names[param_i],
                            "The user should only use one or zero entries in " +
                                parameter_names[param_i] + " if " + block_param_name +
                                " not defined!");
        previous_size = param_vector.size();
      }
      else
      {
        if (previous_size != param_vector.size())
          forwardParamError(parameter_names[param_i],
                            "The number of entries in '" + parameter_names[param_i] +
                                "' is not the same as the number of entries in '" +
                                parameter_names[param_i - 1] + "'!");
      }
    }
  }
}

checkComponentType()

template<typename T >

void PhysicsBase::checkComponentType ( const ActionComponent &  component ) const

inherited

Check that the component is of the desired type.

Definition at line 370 of file PhysicsBase.h.

{
  if (!dynamic_cast<const T *>(&component))
    mooseError("Component '" + component.name() + "' must be of type '" +
               MooseUtils::prettyCppType<T>() + "'.\nIt is currently of type '" + component.type() +
               "'");
}

checkParamsBothSetOrNotSet()

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

protectedinherited

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

Parameters

param1	first parameter to check
param2	second parameter to check

Definition at line 592 of file InputParametersChecksUtils.h.

Referenced by DiffusionPhysicsBase::DiffusionPhysicsBase().

{
  if ((forwardIsParamValid(param1) + forwardIsParamValid(param2)) % 2 != 0)
    forwardParamError(param1,
                      "Parameters '" + param1 + "' and '" + param2 +
                          "' must be either both set or both not set.");
}

checkSecondParamNotSetIfFirstOneSet()

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

protectedinherited

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

Parameters

param1	first parameter to check, check that the second is not if this one is set
param2	second parameter to check, that should not be set if first one is set

Definition at line 628 of file InputParametersChecksUtils.h.

{
  if (forwardIsParamSetByUser(param1) && forwardIsParamSetByUser(param2))
    forwardParamError(param2,
                      "Parameter '" + param2 + "' should not be specified if parameter '" + param1 +
                          "' is specified.");
}

checkSecondParamSetOnlyIfFirstOneSet()

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

protectedinherited

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

Parameters

param1	first parameter to check, check the second if set
param2	second parameter to check, that should be set if first one is set

Definition at line 617 of file InputParametersChecksUtils.h.

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

checkSecondParamSetOnlyIfFirstOneTrue()

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

protectedinherited

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

Parameters

param1	first parameter to check, check the second if true
param2	second parameter to check, that should be set if first one is true

Definition at line 603 of file InputParametersChecksUtils.h.

Referenced by PhysicsBase::PhysicsBase(), and PhysicsBase::prepareCopyVariablesFromMesh().

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

checkTwoDVectorParamInnerSameLengthAsOneDVector()

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

protectedinherited

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

Parameters

param1	two-D vector parameter to check the dimensions of
param2	one-D vector parameter to set the desired size

Definition at line 296 of file InputParametersChecksUtils.h.

{
  assertParamDefined<std::vector<std::vector<T>>>(param1);
  assertParamDefined<std::vector<S>>(param2);
  for (const auto & sub_vec_i : index_range(forwardGetParam<std::vector<std::vector<T>>>(param1)))
  {
    const auto size_1 = forwardGetParam<std::vector<std::vector<T>>>(param1)[sub_vec_i].size();
    const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
    if (size_1 != size_2)
      forwardParamError(param1,
                        "Vector at index " + std::to_string(sub_vec_i) + " (size " +
                            std::to_string(size_1) +
                            ") "
                            " of this parameter should be the same length as parameter '" +
                            param2 + "' (size " + std::to_string(size_2) + ")");
  }
}

checkTwoDVectorParamMultiMooseEnumSameLength()

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

protectedinherited

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

Parameters

param1	two-D vector parameter to check the unrolled size of
param2	MultiMooseEnum parameter to set the desired size

Definition at line 318 of file InputParametersChecksUtils.h.

{
  assertParamDefined<std::vector<std::vector<T>>>(param1);
  assertParamDefined<MultiMooseEnum>(param2);
  const auto vec1 = forwardGetParam<std::vector<std::vector<T>>>(param1);
  const auto enum2 = forwardGetParam<MultiMooseEnum>(param2);
  const auto size_1 = vec1.empty() ? 0 : vec1.size() * vec1[0].size();
  const auto size_2 = enum2.size();
  if (size_1 != size_2)
  {
    if (error_for_param2)
      forwardParamError(param2,
                        "Vector enumeration parameter (size " + std::to_string(size_2) +
                            ") is not the same size as the vector of vector parameter '" + param1 +
                            "' (size " + std::to_string(size_1) + ")");
    else
      forwardParamError(param1,
                        "Vector of vector parameter '" + param1 + "' (total size " +
                            std::to_string(size_1) +
                            ") is not the same size as vector-enumeration parameter '" + param2 +
                            "' (size " + std::to_string(size_2) + ")");
  }
}

checkTwoDVectorParamsNoRespectiveOverlap()

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

protectedinherited

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

Parameters

param_vecs

vector of parameters that should not overlap with each other

Definition at line 395 of file InputParametersChecksUtils.h.

{
  // Outer loop, each param is the name of a parameter for a vector of vectors
  for (const auto & param : param_vec)
  {
    assertParamDefined<std::vector<std::vector<T>>>(param);
    const auto & twoD_vec = forwardGetParam<std::vector<std::vector<T>>>(param);
    std::vector<std::set<T>> unique_params(twoD_vec.size());

    // Loop over each outer vector and compare the inner vectors respectively to other parameters
    for (const auto i : index_range(twoD_vec))
    {
      for (const auto & value : twoD_vec[i])
        if (!unique_params[i].insert(value).second)
        {
          auto copy_params = param_vec;
          copy_params.erase(std::find(copy_params.begin(), copy_params.end(), param));
          forwardMooseError("Item '" + value + "' specified in vector parameter '" + param +
                            "' is also present in one or more of the two-D vector parameters '" +
                            Moose::stringify(copy_params) +
                            "' in the inner vector of the same index, which is not allowed.");
        }
    }
  }
}

checkTwoDVectorParamsSameLength()

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

protectedinherited

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

Parameters

param1	first two-D vector parameter to check the dimensions of
param2	second two-D vector parameter to check the dimensions of

Definition at line 269 of file InputParametersChecksUtils.h.

{
  checkVectorParamsSameLength<std::vector<T>, std::vector<S>>(param1, param2);
  if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
  {
    const auto value1 = forwardGetParam<std::vector<std::vector<T>>>(param1);
    const auto value2 = forwardGetParam<std::vector<std::vector<S>>>(param2);
    for (const auto index : index_range(value1))
      if (value1[index].size() != value2[index].size())
        forwardParamError(
            param1,
            "Vector at index " + std::to_string(index) + " of 2D vector parameter '" + param1 +
                "' is not the same size as its counterpart from 2D vector parameter '" + param2 +
                "'.\nSize first vector: " + std::to_string(value1[index].size()) +
                "\nSize second vector: " + std::to_string(value2[index].size()));
  }
  // handle empty vector defaults
  else if (forwardIsParamValid(param1) || forwardIsParamValid(param2))
    if (forwardGetParam<std::vector<T>>(param1).size() ||
        forwardGetParam<std::vector<T>>(param2).size())
      checkParamsBothSetOrNotSet(param1, param2);
}

checkVectorParamAndMultiMooseEnumLength()

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

protectedinherited

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

Parameters

param1	vector parameter to compare the size of
param2	multiMooseEnum parameter to compare the size of

Definition at line 243 of file InputParametersChecksUtils.h.

{
  assertParamDefined<std::vector<T>>(param1);
  assertParamDefined<MultiMooseEnum>(param2);

  if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
  {
    const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
    const auto size_2 = forwardGetParam<MultiMooseEnum>(param2).size();
    if (size_1 != size_2)
      forwardParamError(param1,
                        "Vector parameters '" + param1 + "' (size " + std::to_string(size_1) +
                            ") and '" + param2 + "' (size " + std::to_string(size_2) +
                            ") must be the same size");
  }
  // handle empty vector defaults
  else if (forwardIsParamValid(param1) || forwardIsParamValid(param2))
    if (forwardGetParam<std::vector<T>>(param1).size() ||
        forwardGetParam<MultiMooseEnum>(param2).size())
      checkParamsBothSetOrNotSet(param1, param2);
}

checkVectorParamLengthSameAsCombinedOthers()

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

protectedinherited

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

Parameters

param1	vector parameter that provides the target size
param2	vector parameter that provides one term in the combined size
param3	vector parameter that provides one term in the combined size

Definition at line 346 of file InputParametersChecksUtils.h.

{
  assertParamDefined<std::vector<T>>(param1);
  assertParamDefined<std::vector<S>>(param2);
  assertParamDefined<std::vector<U>>(param3);
  const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
  const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
  const auto size_3 = forwardGetParam<std::vector<U>>(param3).size();

  if (size_1 != size_2 + size_3)
    forwardParamError(param1,
                      "Vector parameter '" + param1 + "' (size " + std::to_string(size_1) +
                          ") should be the same size as parameter '" + param2 + "' and '" + param3 +
                          " combined (total size " + std::to_string(size_2 + size_3) + ")");
}

checkVectorParamNotEmpty()

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

protectedinherited

Check that the user did not pass an empty vector.

Parameters

param1

vector parameter that should not be empty

Definition at line 425 of file InputParametersChecksUtils.h.

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

checkVectorParamsNoOverlap()

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

protectedinherited

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

Parameters

param_vecs

vector of parameters that should not overlap with each other

Definition at line 366 of file InputParametersChecksUtils.h.

{
  std::set<std::string> unique_params;
  for (const auto & param : param_vec)
  {
    assertParamDefined<std::vector<T>>(param);

    for (const auto & value : forwardGetParam<std::vector<T>>(param))
      if (!unique_params.insert(value).second)
      {
        auto copy_params = param_vec;
        copy_params.erase(std::find(copy_params.begin(), copy_params.end(), param));
        // Overlap between multiple vectors of parameters
        if (copy_params.size())
          forwardMooseError("Item '" + value + "' specified in vector parameter '" + param +
                            "' is also present in one or more of the parameters '" +
                            Moose::stringify(copy_params) + "', which is not allowed.");
        // Overlap within a single vector parameter caused by a repeated item
        else
          forwardMooseError("Item '" + value + "' specified in vector parameter '" + param +
                            "' is repeated, which is not allowed.");
      }
  }
}

checkVectorParamsSameLength()

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

protectedinherited

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

Parameters

param1	first vector parameter to compare the size of
param2	second vector parameter to compare the size of

Definition at line 217 of file InputParametersChecksUtils.h.

{
  assertParamDefined<std::vector<T>>(param1);
  assertParamDefined<std::vector<S>>(param2);

  if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
  {
    const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
    const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
    if (size_1 != size_2)
      forwardParamError(param1,
                        "Vector parameters '" + param1 + "' (size " + std::to_string(size_1) +
                            ") and '" + param2 + "' (size " + std::to_string(size_2) +
                            ") must be the same size");
  }
  // handle empty vector defaults
  else if (forwardIsParamValid(param1) || forwardIsParamValid(param2))
    if (forwardGetParam<std::vector<T>>(param1).size() ||
        forwardGetParam<std::vector<T>>(param2).size())
      checkParamsBothSetOrNotSet(param1, param2);
}

checkVectorParamsSameLengthIfSet()

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

protectedinherited

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

Parameters

param1	first vector parameter to check the size of
param2	second vector parameter to check the size of

Definition at line 435 of file InputParametersChecksUtils.h.

{
  assertParamDefined<std::vector<T>>(param1);
  assertParamDefined<std::vector<S>>(param2);

  if (forwardIsParamValid(param1) && forwardIsParamValid(param2))
  {
    const auto size_1 = forwardGetParam<std::vector<T>>(param1).size();
    const auto size_2 = forwardGetParam<std::vector<S>>(param2).size();
    if (ignore_empty_default_param2 && (size_2 == 0) && !forwardIsParamSetByUser(param2))
      return;
    if (size_1 != size_2)
      forwardParamError(param1,
                        "Parameter '" + param1 + "' (size " + std::to_string(size_1) + ") and '" +
                            param2 + "' (size " + std::to_string(size_2) +
                            ") must be the same size if set.");
  }
}

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

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 74 of file MooseBase.C.

{
  auto & factory = _app.getFactory();
  auto & ip_warehouse = _app.getInputParameterWarehouse();

  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = factory.getValidParams(object_type).getBase();
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);

  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
  for (const auto & tag : tags)
  {
    if (!tag.empty())
    {
      // Only adds the parameter with the different control tags if the derived class
      // properly registers the parameter to its own syntax
      MooseObjectParameterName tagged_name(tag, name(), parameter);
      ip_warehouse.addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

copyVariablesFromMesh()

void PhysicsBase::copyVariablesFromMesh ( const std::vector< VariableName > &  variables_to_copy, bool  are_nonlinear = true  )

protectedinherited

Copy nonlinear or aux variables from the mesh file.

Parameters

variables_to_copy	Nonlinear or aux (not a mix) variables
are_nonlinear	True if variables_to_copy are nonlinear; else, aux

Definition at line 399 of file PhysicsBase.C.

Referenced by PhysicsBase::act().

{
  if (getParam<bool>("initialize_variables_from_mesh_file"))
  {
    mooseInfoRepeated("Adding Exodus restart for " + std::to_string(variables_to_copy.size()) +
                      " variables: " + Moose::stringify(variables_to_copy));
    // TODO Check that the variable types and orders are actually supported for exodus restart
    for (const auto i : index_range(variables_to_copy))
    {
      SystemBase & system = are_solver_var ? getProblem().getSystemBase(_system_numbers.size() == 1
                                                                            ? _system_numbers[0]
                                                                            : _system_numbers[i])
                                           : getProblem().systemBaseAuxiliary();
      const auto & var_name = variables_to_copy[i];
      system.addVariableToCopy(
          var_name, var_name, getParam<std::string>("initial_from_file_timestep"));
    }
  }
}

dimension()

unsigned int PhysicsBase::dimension ( ) const

inherited

Return the maximum dimension of the blocks the Physics is active on.

Definition at line 245 of file PhysicsBase.C.

{
  mooseAssert(_mesh, "We dont have a mesh yet");
  mooseAssert(_dim < 4, "Dimension has not been set yet");
  return _dim;
}

errorDependentParameter()

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

protectedinherited

Error messages for parameters that should depend on another parameter.

Parameters

param1	the parameter has not been set to the desired value (for logging purposes)
value_not_set	the desired value (for logging purposes)
dependent_params	all the parameters that should not have been since 'param1' was not set to 'value_not_set'

Definition at line 562 of file InputParametersChecksUtils.h.

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

errorInconsistentDependentParameter()

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

protectedinherited

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

Parameters

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

Definition at line 577 of file InputParametersChecksUtils.h.

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

errorPrefix()

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

inlineinherited

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

Definition at line 260 of file MooseBase.h.

{ return messagePrefix(); }

getActionComponent()

const ActionComponent & PhysicsBase::getActionComponent ( const ComponentName &  comp_name ) const

inherited

Get a component with the requested name.

Definition at line 318 of file PhysicsBase.C.

Referenced by DiffusionPhysicsBase::addInitialConditions(), and DiffusionPhysicsBase::addInitialConditionsFromComponents().

{
  return _awh.getAction<ActionComponent>(comp_name);
}

getAdditionalRMParams()

virtual InputParameters PhysicsBase::getAdditionalRMParams ( ) const

inlinevirtualinherited

Provide additional parameters for the relationship managers.

Reimplemented in DiffusionFV.

Definition at line 38 of file PhysicsBase.h.

Referenced by PhysicsBase::addRelationshipManagers().

{ return emptyInputParameters(); };

getAllTasks()

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

inlineinherited

Definition at line 105 of file Action.h.

Referenced by AddKernelAction::act().

{ return _all_tasks; }

getBase()

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

inlineinherited

Returns

The registered base for this object (set via InputParameters::registerBase())

Definition at line 143 of file MooseBase.h.

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

{ return _pars.getBase(); }

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 428 of file MooseBase.h.

{
  return _pars.getCheckedPointerParam<T>(name, error_string);
}

getCoupledPhysics() [1/2]

template<typename T >

const T * PhysicsBase::getCoupledPhysics ( const PhysicsName &  phys_name, const bool  allow_fail = false  ) const

inherited

Get a Physics from the ActionWarehouse with the requested type and name.

Parameters

phys_name	name of the Physics to retrieve
allow_fail	whether to allow returning a nullptr if the physics does not exist

Definition at line 333 of file PhysicsBase.h.

{
  constexpr bool is_physics = std::is_base_of<PhysicsBase, T>::value;
  libmesh_ignore(is_physics);
  mooseAssert(is_physics, "Must be a PhysicsBase to be retrieved by getCoupledPhysics");
  const auto all_T_physics = _awh.getActions<T>();
  for (const auto * const physics : all_T_physics)
  {
    if (physics->name() == phys_name)
      return physics;
  }
  if (!allow_fail)
    mooseError("Requested Physics '",
               phys_name,
               "' does not exist or is not of type '",
               MooseUtils::prettyCppType<T>(),
               "'");
  else
    return nullptr;
}

getCoupledPhysics() [2/2]

template<typename T >

const std::vector< T * > PhysicsBase::getCoupledPhysics ( const bool  allow_fail = false ) const

inherited

Get all Physics from the ActionWarehouse with the requested type.

Definition at line 356 of file PhysicsBase.h.

{
  constexpr bool is_physics = std::is_base_of<PhysicsBase, T>::value;
  libmesh_ignore(is_physics);
  mooseAssert(is_physics, "Must be a PhysicsBase to be retrieved by getCoupledPhysics");
  const auto all_T_physics = _awh.getActions<T>();
  if (!allow_fail && all_T_physics.empty())
    mooseError("No Physics of requested type '", MooseUtils::prettyCppType<T>(), "'");
  else
    return all_T_physics;
}

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.

{
  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
                          "within the InputParameters.\nUse getParam<DataFileName>(\"",
                          param,
                          "\") instead.");
  return _parent.getParam<DataFileName>(param);
}

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.

{
  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                          relative_path,
                          "\") instead.");
  return getDataFilePath(relative_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.

Referenced by DataFileInterface::getDataFileNameByName().

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");

  // Throw on error so that if getPath() fails, we can throw an error
  // with the context of _parent.mooseError()
  const auto throw_on_error_before = Moose::_throw_on_error;
  Moose::_throw_on_error = true;
  std::optional<std::string> error;

  // This will search the data paths for this relative path
  Moose::DataFileUtils::Path found_path;
  try
  {
    found_path = Moose::DataFileUtils::getPath(relative_path);
  }
  catch (std::exception & e)
  {
    error = e.what();
  }

  Moose::_throw_on_error = throw_on_error_before;
  if (error)
    _parent.mooseError(*error);

  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");

  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);

  return found_path.path;
}

getFactory() [1/2]

Factory& PhysicsBase::getFactory ( )

inlineprotectedinherited

Get the factory for this physics The factory lets you get the parameters for objects.

Definition at line 108 of file PhysicsBase.h.

Referenced by DiffusionCG::addBoundaryConditionsFromComponents(), DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), DiffusionPhysicsBase::addInitialConditionsFromComponents(), DiffusionFV::addSolverVariables(), DiffusionCG::addSolverVariables(), and DiffusionFV::getAdditionalRMParams().

{ return _factory; }

getFactory() [2/2]

Factory& PhysicsBase::getFactory ( ) const

inlineprotectedinherited

Definition at line 109 of file PhysicsBase.h.

{ return _factory; }

getHitNode()

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

inlineinherited

Returns

The block-level hit node for this object, if any

Definition at line 132 of file MooseBase.h.

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

{ return getHitNode(_pars); }

getMeshProperty() [1/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 134 of file MeshMetaDataInterface.h.

{
  if (!hasMeshProperty(data_name, prefix))
    mooseErrorInternal("Failed to get mesh property '", prefix, "/", data_name, "'");

  auto value = &getMeshPropertyInternal(data_name, prefix);
  mooseAssert(value->declared(), "Value has not been declared");
  const RestartableData<T> * T_value = dynamic_cast<const RestartableData<T> *>(value);
  if (!T_value)
    mooseErrorInternal("While retrieving mesh property '",
                       prefix,
                       "/",
                       data_name,
                       "' with type '",
                       MooseUtils::prettyCppType<T>(),
                       "',\nthe property exists with different type '",
                       value->type(),
                       "'");
  return T_value->get();
}

getMeshProperty() [2/2]

template<typename T >

const T& MeshMetaDataInterface::getMeshProperty ( const std::string &  data_name )

inlineprotectedinherited

Definition at line 56 of file MeshMetaDataInterface.h.

  {
    return getMeshProperty<T>(data_name, meshPropertyPrefix(data_name));
  }

getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 83 of file MooseBase.h.

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

{ return _app; }

getParam() [1/2]

template<typename T >

const T & MooseBase::getParam ( const std::string &  name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 384 of file MooseBase.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FEProblemBase::addOutput(), DiffusionPhysicsBase::addPostprocessors(), ADNodalKernel::ADNodalKernel(), ArrayParsedAux::ArrayParsedAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), ComponentPhysicsInterface::ComponentPhysicsInterface(), FunctorAux::computeValue(), Console::Console(), FEProblemBase::createTagSolutions(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), FEProblemSolve::FEProblemSolve(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), GhostingUserObject::GhostingUserObject(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MultiSystemSolveObject::MultiSystemSolveObject(), NEML2ModelExecutor::NEML2ModelExecutor(), NestedDivision::NestedDivision(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), Output::setWallTimeIntervalFromCommandLineParam(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

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

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

param1	The name of first parameter
param2	The name of second parameter

Returns

Vector of pairs of first and second parameters

Definition at line 421 of file MooseBase.h.

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

getProblem() [1/2]

virtual FEProblemBase& PhysicsBase::getProblem ( )

inlineprotectedvirtualinherited

Get the problem for this physics Useful to add objects to the simulation.

Definition at line 112 of file PhysicsBase.h.

Referenced by DiffusionCG::addBoundaryConditionsFromComponents(), DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), DiffusionPhysicsBase::addInitialConditionsFromComponents(), DiffusionPhysicsBase::addPostprocessors(), DiffusionFV::addSolverVariables(), DiffusionCG::addSolverVariables(), PhysicsBase::checkIntegrityEarly(), PhysicsBase::copyVariablesFromMesh(), PhysicsBase::initializePhysics(), DiffusionFV::initializePhysicsAdditional(), and PhysicsBase::isTransient().

  {
    mooseAssert(_problem, "Requesting the problem too early");
    return *_problem;
  }

getProblem() [2/2]

virtual const FEProblemBase& PhysicsBase::getProblem ( ) const

inlineprotectedvirtualinherited

Definition at line 117 of file PhysicsBase.h.

  {
    mooseAssert(_problem, "Requesting the problem too early");
    return *_problem;
  }

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_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 398 of file MooseBase.h.

{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

getSolverSystem() [1/2]

const SolverSystemName & PhysicsBase::getSolverSystem ( unsigned int  variable_index ) const

protectedinherited

Get the solver system for this variable index.

The index should be the index of the variable in solver var_names (currently _solver_var_names) vector

Definition at line 440 of file PhysicsBase.C.

Referenced by DiffusionCG::addSolverVariables(), and DiffusionFV::addSolverVariables().

{
  mooseAssert(!_system_names.empty(), "We should have a solver system name");
  if (_system_names.size() == 1)
    return _system_names[0];
  else
    // We trust that the system names and the variable names match one-to-one as it is enforced by
    // the checkIntegrityEarly() routine.
    return _system_names[variable_index];
}

getSolverSystem() [2/2]

const SolverSystemName & PhysicsBase::getSolverSystem ( const VariableName &  variable_name ) const

protectedinherited

Get the solver system for this variable name.

Definition at line 452 of file PhysicsBase.C.

{
  mooseAssert(!_system_names.empty(), "We should have a solver system name");
  // No need to look if only one system for the Physics
  if (_system_names.size() == 1)
    return _system_names[0];

  // We trust that the system names and the variable names match one-to-one as it is enforced by
  // the checkIntegrityEarly() routine.
  for (const auto variable_index : index_range(_solver_var_names))
    if (var_name == _solver_var_names[variable_index])
      return _system_names[variable_index];
  mooseError("Variable '", var_name, "' was not found within the Physics solver variables.");
}

getSubdomainIDs()

std::set< SubdomainID > PhysicsBase::getSubdomainIDs ( const std::set< SubdomainName > &  blocks ) const

protectedinherited

Get the set of subdomain ids for the incoming vector of subdomain names.

Definition at line 253 of file PhysicsBase.C.

Referenced by PhysicsBase::shouldCreateIC(), and PhysicsBase::shouldCreateTimeDerivative().

{
  const bool not_block_restricted =
      (std::find(blocks.begin(), blocks.end(), "ANY_BLOCK_ID") != blocks.end()) ||
      allMeshBlocks(blocks);
  mooseAssert(_mesh, "Should have a mesh");
  // use a set for simplicity. Note that subdomain names are unique, except maybe the empty one,
  // which cannot be specified by the user to the Physics.
  // MooseMesh::getSubdomainIDs cannot deal with the 'ANY_BLOCK_ID' name
  std::set<SubdomainID> block_ids_set =
      not_block_restricted ? _mesh->meshSubdomains() : _mesh->getSubdomainIDs(blocks);
  return block_ids_set;
}

getSubdomainNamesAndIDs()

std::vector< std::string > PhysicsBase::getSubdomainNamesAndIDs ( const std::set< SubdomainID > &  blocks ) const

protectedinherited

Get the vector of subdomain names and ids for the incoming set of subdomain IDs.

Definition at line 268 of file PhysicsBase.C.

Referenced by PhysicsBase::shouldCreateIC(), and PhysicsBase::shouldCreateTimeDerivative().

{
  mooseAssert(_mesh, "Should have a mesh");
  std::vector<std::string> sub_names_ids;
  sub_names_ids.reserve(blocks.size());
  for (const auto bid : blocks)
  {
    const auto bname = _mesh->getSubdomainName(bid);
    sub_names_ids.push_back((bname.empty() ? "(unnamed)" : bname) + " (" + std::to_string(bid) +
                            ")");
  }
  return sub_names_ids;
}

hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns

Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 138 of file MooseBase.h.

{ return _pars.hasBase(); }

hasMeshProperty() [1/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 25 of file MeshMetaDataInterface.C.

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

{
  return _meta_data_app.hasRestartableMetaData(meshPropertyName(data_name, prefix),
                                               MooseApp::MESH_META_DATA);
}

hasMeshProperty() [2/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 158 of file MeshMetaDataInterface.h.

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

hasMeshProperty() [3/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 74 of file MeshMetaDataInterface.h.

  {
    return hasMeshProperty(data_name, meshPropertyPrefix(data_name));
  }

hasMeshProperty() [4/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 82 of file MeshMetaDataInterface.h.

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

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

name	The name of the parameter to test

Definition at line 201 of file MooseBase.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

  {
    return _pars.isParamSetByUser(name);
  }

isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 195 of file MooseBase.h.

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

{ return _pars.isParamValid(name); }

isTransient()

bool PhysicsBase::isTransient ( ) const

protectedinherited

Return whether the Physics is solved using a transient.

Definition at line 233 of file PhysicsBase.C.

Referenced by PhysicsBase::checkIntegrityEarly(), and PhysicsBase::shouldCreateTimeDerivative().

{
  mooseAssert(_problem, "We don't have a problem yet");
  if (_is_transient == "true")
    return true;
  else if (_is_transient == "false")
    return false;
  else
    return getProblem().isTransient();
}

isVariableFV()

bool PhysicsBase::isVariableFV ( const VariableName &  var_name ) const

protectedinherited

Whether the variable is a finite volume variable.

Definition at line 589 of file PhysicsBase.C.

Referenced by PhysicsBase::shouldCreateIC().

{
  const auto var = &_problem->getVariable(0, var_name);
  return var->isFV();
}

isVariableScalar()

bool PhysicsBase::isVariableScalar ( const VariableName &  var_name ) const

protectedinherited

Whether the variable is a scalar variable (global single scalar, not a field)

Definition at line 596 of file PhysicsBase.C.

Referenced by PhysicsBase::shouldCreateIC(), and PhysicsBase::shouldCreateTimeDerivative().

{
  return _problem->hasScalarVariable(var_name);
}

meshPropertyName() [1/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 33 of file MeshMetaDataInterface.C.

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

{
  return std::string(SYSTEM) + "/" + prefix + "/" + data_name;
}

meshPropertyName() [2/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 95 of file MeshMetaDataInterface.h.

  {
    return meshPropertyName(data_name, meshPropertyPrefix(data_name));
  }

messagePrefix()

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 252 of file MooseBase.h.

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

  {
    return messagePrefix(_pars, hit_prefix);
  }

mooseDeprecated()

template<typename... Args>

void MooseBase::mooseDeprecated ( Args &&...  args ) const

inlineinherited

Definition at line 310 of file MooseBase.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), MooseApp::getRecoverFileBase(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MooseApp::hasRecoverFileBase(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), MooseApp::setupOptions(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

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

mooseDocumentedError()

template<typename... Args>

void MooseBase::mooseDocumentedError ( const std::string &  repo_name, const unsigned int  issue_num, Args &&...  args  ) const

inlineinherited

Definition at line 273 of file MooseBase.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

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 267 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), CheckFVBCAction::act(), AddICAction::act(), InitProblemAction::act(), AddBoundsVectorsAction::act(), AutoCheckpointAction::act(), CreateExecutionerAction::act(), SetupMeshCompleteAction::act(), AddVectorPostprocessorAction::act(), AddMeshGeneratorAction::act(), CheckIntegrityAction::act(), AddFVICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), ChainControlSetupAction::act(), DeprecatedBlockAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), CreateDisplacedProblemAction::act(), MaterialDerivativeTestAction::act(), SetAdaptivityOptionsAction::act(), MaterialOutputAction::act(), AddMFEMSubMeshAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::adaptMesh(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), addBoundaryConditionsFromComponents(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFVInitialCondition(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInitialCondition(), addInitialConditionsFromComponents(), FEProblemBase::addInterfaceKernel(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), MFEMProblem::addMaterial(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DiracKernelBase::addPoint(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addScalarKernel(), AddVariableAction::addVariable(), FEProblemBase::addVectorPostprocessor(), SubProblem::addVectorTag(), MooseLinearVariableFV< Real >::adError(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), NEML2ModelExecutor::applyPredictor(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), MooseApp::attachRelationshipManagers(), AddPeriodicBCAction::autoTranslationBoundaries(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), TimedSubdomainModifier::buildFromParameters(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), MooseMesh::buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildSideList(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), FEProblemBase::checkExceptionAndStopSolve(), NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), DefaultMultiAppFixedPointConvergence::checkIterationType(), DefaultNonlinearConvergence::checkIterationType(), DefaultSteadyStateConvergence::checkIterationType(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), MooseApp::checkReservedCapability(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), FEProblemBase::checkUserObjects(), Moose::PetscSupport::checkUserProvidedPetscOption(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), LibmeshPartitioner::clone(), MooseMesh::clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), InternalSideIntegralPostprocessor::computeFaceInfoIntegral(), SideIntegralPostprocessor::computeFaceInfoIntegral(), MooseVariableFieldBase::computeFaceValues(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), FVFluxKernel::computeJacobian(), NodalConstraint::computeJacobian(), FEProblemBase::computeJacobianTags(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), EigenProblem::computeMatricesTags(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), FVElementalKernel::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), SideFVFluxBCIntegral::computeQpIntegral(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), NodeElemConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), MassMatrix::computeQpResidual(), HDGKernel::computeQpResidual(), DiffusionLHDGDirichletBC::computeQpResidual(), NodalEqualValueConstraint::computeQpResidual(), DiffusionLHDGPrescribedGradientBC::computeQpResidual(), IPHDGBC::computeQpResidual(), KernelValue::computeQpResidual(), TorchScriptMaterial::computeQpValues(), InterfaceQpValueUserObject::computeRealValue(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FVFluxBC::computeResidual(), FVFluxKernel::computeResidual(), NodalConstraint::computeResidual(), FVFluxKernel::computeResidualAndJacobian(), ResidualObject::computeResidualAndJacobian(), FEProblemBase::computeResidualAndJacobian(), HDGKernel::computeResidualAndJacobianOnSide(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), KernelScalarBase::computeScalarOffDiagJacobian(), ADKernelScalarBase::computeScalarQpResidual(), ADMortarScalarBase::computeScalarQpResidual(), MortarScalarBase::computeScalarQpResidual(), KernelScalarBase::computeScalarQpResidual(), TimeStepper::computeStep(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CentralDifference::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), MultiAppGeometricInterpolationTransfer::computeTransformation(), BuildArrayVariableAux::computeValue(), TagVectorArrayVariableAux::computeValue(), NearestNodeValueAux::computeValue(), ProjectionAux::computeValue(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), MooseVariableFV< Real >::curlPhi(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), SidesetInfoVectorPostprocessor::dataHelper(), ReporterTransferInterface::declareClone(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), MooseApp::determineLibtorchDeviceType(), FEProblemBase::determineSolverSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementMaterialSampler::ElementMaterialSampler(), ElementQualityAux::ElementQualityAux(), ElementUOAux::ElementUOAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), EigenKernel::enabled(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), SideIntegralPostprocessor::errorNoFaceInfo(), SideIntegralFunctorPostprocessorTempl< false >::errorNoFaceInfo(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), FixedPointSolve::examineFixedPointConvergence(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), RealToBoolChainControl::execute(), DiscreteElementUserObject::execute(), RestartableDataReporter::execute(), MultiAppScalarToAuxScalarTransfer::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), NodalValueSampler::execute(), PositionsFunctorValueSampler::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), MultiAppPostprocessorTransfer::execute(), ElementQualityChecker::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpUserObjectBase::execute(), MultiAppGeometricInterpolationTransfer::execute(), WebServerControl::execute(), TransientBase::execute(), LeastSquaresFit::execute(), VectorPostprocessorComparison::execute(), LeastSquaresFitHistory::execute(), Eigenvalue::execute(), TimeExtremeValue::execute(), DomainUserObject::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), MooseApp::executeExecutioner(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), NEML2ModelExecutor::extractOutputs(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), NEML2ModelExecutor::fillInputs(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyNodalUniqueID::finalize(), VerifyElementUniqueID::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), DiscreteVariableResidualNorm::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), MooseApp::finalizeRestore(), Transfer::find_sys(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), ElementSubdomainModifierBase::gatherPatchElements(), Boundary2DDelaunayGenerator::General2DDelaunay(), ElementOrderConversionGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SmoothMeshGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), MoveNodeGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), SideSetsFromPointsGenerator::generate(), StitchMeshGenerator::generate(), BreakMeshByBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), Boundary2DDelaunayGenerator::generate(), CoarsenBlockGenerator::generate(), MeshDiagnosticsGenerator::generate(), MeshRepairGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), CombinerGenerator::generate(), AdvancedExtruderGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedGenerateNodeset::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), CutMeshByLevelSetGeneratorBase::generate(), SubdomainBoundingBoxGenerator::generate(), PatternedMeshGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), RandomICBase::generateRandom(), GenericConstantMaterialTempl< is_ad >::GenericConstantMaterialTempl(), GenericConstantVectorMaterialTempl< is_ad >::GenericConstantVectorMaterialTempl(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), DisplacedProblem::getActualFieldVariable(), FEProblemBase::getActualFieldVariable(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getAxisymmetricRadialCoord(), MFEMFESpace::getBasis(), NEML2BatchIndexGenerator::getBatchIndex(), MooseMesh::getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), MooseMesh::getCoarseningMap(), NodalPatchRecoveryBase::getCoefficients(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), FEProblemBase::getConvergence(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PropertyReadFile::getData(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), FEProblemBase::getDistribution(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), GhostingUserObject::getElementalValue(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), PropertyReadFile::getElementData(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), MultiAppFieldTransfer::getEquationSystem(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MFEMVectorFESpace::getFECName(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVMatsAndDependencies(), MooseMesh::getGeneralAxisymmetricCoordAxis(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), FEProblemBase::getLinearConvergenceNames(), SolutionUserObjectBase::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), SubProblem::getMatrixTagID(), GeneratedMesh::getMaxInDimension(), AnnularMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), FEProblemBase::getMultiAppFixedPointConvergenceName(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), MooseMesh::getNodeBlockIds(), PropertyReadFile::getNodeData(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearConvergenceNames(), EigenProblem::getNonlinearEigenSystem(), FEProblemBase::getNonlinearSystem(), NEML2ModelExecutor::getOutput(), NEML2ModelExecutor::getOutputDerivative(), NEML2ModelExecutor::getOutputParameterDerivative(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), PlaneIDMeshGenerator::getPlaneID(), Positions::getPosition(), Positions::getPositions(), FEProblemBase::getPositionsObject(), Positions::getPositionsVector2D(), Positions::getPositionsVector3D(), Positions::getPositionsVector4D(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), ComponentMaterialPropertyInterface::getPropertyValue(), InterfaceQpUserObjectBase::getQpValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), FEProblemBase::getSampler(), WebServerControl::getScalarJSONValue(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), MooseObject::getSharedPtr(), InterfaceQpUserObjectBase::getSideAverageValue(), PhysicsBase::getSolverSystem(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSteadyStateConvergenceName(), MooseMesh::getSubdomainBoundaryIds(), TimedSubdomainModifier::getSubdomainIDAndCheck(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), Times::getTimeAtIndex(), FEProblemBase::getTimeFromStateArg(), TransientBase::getTimeIntegratorNames(), Times::getTimes(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorComponent::getValue(), NumRelationshipManagers::getValue(), Residual::getValue(), SideAverageValue::getValue(), JSONFileReader::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingFromUOAux::GhostingFromUOAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), HDGKernel::HDGKernel(), TransientBase::incrementStepOrReject(), FixedPointIterationAdaptiveDT::init(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), EigenExecutionerBase::init(), ExplicitTimeIntegrator::init(), FEProblem::init(), TransientBase::init(), AddAuxVariableAction::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), DistributedPositions::initialize(), ReporterPositions::initialize(), TransformedPositions::initialize(), ElementGroupCentroidPositions::initialize(), FunctorPositions::initialize(), ReporterTimes::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), ChainControlDataPostprocessor::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), PiecewiseLinearBase::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVAdvection::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), SolutionScalarAux::initialSetup(), LinearFVDiffusion::initialSetup(), SolutionAux::initialSetup(), ExplicitTimeIntegrator::initialSetup(), ReferenceResidualConvergence::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), ElementSubdomainModifierBase::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), SolutionUserObjectBase::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Function::integral(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), InternalSideIndicatorBase::InternalSideIndicatorBase(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MooseApp::loadLibraryAndDependencies(), MultiAppGeneralFieldTransfer::locatePointReceivers(), LowerBoundNodalKernel::LowerBoundNodalKernel(), MooseLinearVariableFV< Real >::lowerDError(), PNGOutput::makePNG(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), MassMatrix::MassMatrix(), Material::Material(), MaterialRealTensorValueAuxTempl< is_ad >::MaterialRealTensorValueAuxTempl(), MaterialRealVectorValueAuxTempl< T, is_ad, is_functor >::MaterialRealVectorValueAuxTempl(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseLinearVariableFV< Real >::nodalError(), MooseVariableFV< Real >::nodalMatrixTagValue(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalScalarKernel::NodalScalarKernel(), MooseVariableFV< Real >::nodalValueArray(), MooseVariableFV< Real >::nodalValueOldArray(), MooseVariableFV< Real >::nodalValueOlderArray(), NodalVariableValue::NodalVariableValue(), MooseVariableFV< Real >::nodalVectorTagValue(), DistributedRectilinearMeshGenerator::nodeId(), MooseVariableFV< Real >::numberOfDofsNeighbor(), NumDOFs::NumDOFs(), NumFailedTimeSteps::NumFailedTimeSteps(), DistributedRectilinearMeshGenerator::numNeighbors(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), XDA::output(), SolutionHistory::output(), Exodus::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), MooseApp::outputMachineReadableData(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), DistributedRectilinearMeshGenerator::paritionSquarely(), PiecewiseBilinear::parse(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), MultiAppConservativeTransfer::performAdjustment(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), MooseVariableFV< Real >::phiLowerSize(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), AStableDirk4::postResidual(), LStableDirk4::postResidual(), ExplicitRK2::postResidual(), EigenProblem::postScaleEigenVector(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), ADKernelValueTempl< T >::precomputeQpJacobian(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), ElementSubdomainModifierBase::prepareVariableForReinitialization(), FixedPointSolve::printFixedPointConvergenceReason(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), MFEMTransient::relativeSolutionDifferenceNorm(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), PiecewiseMultiInterpolation::sample(), ScalarComponentIC::ScalarComponentIC(), MortarScalarBase::scalarVariable(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), BicubicSplineFunction::secondDerivative(), MooseVariableFV< Real >::secondPhi(), MooseVariableFV< Real >::secondPhiFace(), MooseVariableFV< Real >::secondPhiFaceNeighbor(), MooseVariableFV< Real >::secondPhiNeighbor(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), FEProblemBase::setCoupling(), PiecewiseBase::setData(), FileOutput::setFileBaseInternal(), MooseMesh::setGeneralAxisymmetricCoordAxes(), FEProblemSolve::setInnerSolve(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), AddPeriodicBCAction::setPeriodicVars(), MFEMSolverBase::setPreconditioner(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), TimePeriodBase::setupTimes(), IntegratedBCBase::shouldApply(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SideAdvectiveFluxIntegralTempl< is_ad >::SideAdvectiveFluxIntegralTempl(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObjectBase::SolutionUserObjectBase(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TimeIntegrator::solve(), FEProblemBase::solverSysNum(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointIntegralVariablePostprocessor::spatialValue(), NearestPointAverage::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), WebServerControl::stringifyJSONType(), MultiAppGeometricInterpolationTransfer::subdomainIDsNode(), Constraint::subdomainSetup(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), MaterialBase::subdomainSetup(), FEProblemBase::swapBackMaterialsNeighbor(), DisplacedProblem::systemBaseLinear(), Console::systemInfoFlags(), FEProblemBase::systemNumForVariable(), TerminateChainControl::terminate(), Terminator::Terminator(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), Function::timeDerivative(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeExtremeValue::TimeExtremeValue(), Function::timeIntegral(), MooseLinearVariableFV< Real >::timeIntegratorError(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), WebServerControl::toMiniJson(), MultiAppDofCopyTransfer::transfer(), MultiAppMFEMCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), MooseBase::uniqueName(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObjectBase::updateExodusBracketingTimeIndices(), FEProblemBase::updateMaxQps(), MFEMHypreADS::updateSolver(), MFEMHypreAMS::updateSolver(), MFEMHyprePCG::updateSolver(), MFEMHypreBoomerAMG::updateSolver(), MFEMCGSolver::updateSolver(), MFEMHypreFGMRES::updateSolver(), MFEMGMRESSolver::updateSolver(), MFEMOperatorJacobiSmoother::updateSolver(), MFEMHypreGMRES::updateSolver(), MFEMSuperLU::updateSolver(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointIntegralVariablePostprocessor::userObjectValue(), NearestPointAverage::userObjectValue(), BoundingBoxIC::value(), PiecewiseConstantFromCSV::value(), IntegralPreservingFunctionIC::value(), Axisymmetric2D3DSolutionFunction::value(), Function::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), AddVariableAction::variableType(), VariableValueVolumeHistogram::VariableValueVolumeHistogram(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), VectorNodalBC::VectorNodalBC(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), VTKOutput::VTKOutput(), WebServerControl::WebServerControl(), MooseApp::writeRestartableMetaData(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

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

mooseErrorNonPrefixed()

template<typename... Args>

void MooseBase::mooseErrorNonPrefixed ( Args &&...  args ) const

inlineinherited

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

Definition at line 286 of file MooseBase.h.

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

mooseInfo()

template<typename... Args>

void MooseBase::mooseInfo ( Args &&...  args ) const

inlineinherited

Definition at line 317 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MFEMScalarFESpace::getFECName(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

  {
    moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

mooseWarning()

template<typename... Args>

void MooseBase::mooseWarning ( Args &&...  args ) const

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 295 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), DataFileInterface::getDataFilePath(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseApp::loadLibraryAndDependencies(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramWarning(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

  {
    moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

mooseWarningNonPrefixed()

template<typename... Args>

void MooseBase::mooseWarningNonPrefixed ( Args &&...  args ) const

inlineinherited

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

Definition at line 304 of file MooseBase.h.

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

name()

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

inlineinherited

Get the name of the class.

Returns

The name of the class

Definition at line 99 of file MooseBase.h.

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), DeprecatedBlockAction::act(), SetupTimeIntegratorAction::act(), AddActionComponentAction::act(), SetupResidualDebugAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), Registry::addDataFilePath(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), SubProblem::addFunctor(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DiffusionLHDGKernel::additionalROVariables(), IPHDGAssemblyHelper::additionalROVariables(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), InitialConditionWarehouse::addObject(), FEProblemBase::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), UserObject::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), UserObject::addUserObjectDependencyHelper(), AuxKernelTempl< Real >::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), UserObject::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< Real >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), Registry::appNameFromAppPath(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), AuxKernelTempl< Real >::AuxKernelTempl(), Function::average(), MultiApp::backup(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MFEMFESpace::buildFEC(), PiecewiseTabularBase::buildFromFile(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), ParsedConvergence::checkConvergence(), DefaultNonlinearConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), SamplerBase::checkForStandardFieldVariableType(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), DomainUserObject::checkVariable(), BlockRestrictable::checkVariable(), Coupleable::checkWritableVar(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBase::connectControllableParams(), ConstantPostprocessor::ConstantPostprocessor(), Coupleable::coupledName(), CommonOutputAction::create(), MultiApp::createApp(), MooseApp::createExecutors(), MeshGeneratorSystem::createMeshGeneratorOrder(), MooseApp::createRecoverablePerfGraph(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), DebugResidualAux::DebugResidualAux(), MaterialBase::declareADProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), Registry::determineDataFilePath(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), SideValueSampler::execute(), RestartableDataReporter::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), WebServerControl::execute(), MultiAppGeneralFieldTransfer::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FunctionIC::functionName(), FVFunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), MooseServer::gatherDocumentSymbols(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), Registry::getDataFilePath(), UserObject::getDependObjects(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), MooseApp::getExecutor(), FEProblemBase::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), AuxKernelTempl< Real >::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), MFEMGeneralUserObject::getMatrixCoefficient(), MFEMGeneralUserObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), ActionWarehouse::getMooseAppName(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), MooseServer::getObjectParameters(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), OutputWarehouse::getOutput(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMGeneralUserObject::getScalarCoefficient(), MFEMGeneralUserObject::getScalarCoefficientByName(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMGeneralUserObject::getVectorCoefficient(), MFEMGeneralUserObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), MooseApp::hasMeshGenerator(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), IterationAdaptiveDT::init(), AddVariableAction::init(), AdvancedOutput::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), JSONOutput::initialSetup(), SideFVFluxBCIntegral::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), NodalVariableValue::initialSetup(), Console::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< MortarScalarBase >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< Real >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), MatDiffusionBase< Real >::MatDiffusionBase(), Material::Material(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), OutputWarehouse::mooseConsole(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MooseLinearVariableFV< Real >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), Registry::objData(), MeshGenerator::Comparator::operator()(), ProgressOutput::output(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), MooseApp::possiblyLoadRestartableMetaData(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), AppFactory::reg(), Registry::registerObjectsTo(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), GlobalParamsAction::remove(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), GlobalParamsAction::setDoubleIndexParam(), OutputWarehouse::setFileNumbers(), GlobalParamsAction::setParam(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), GlobalParamsAction::setScalarParam(), MooseMesh::setSubdomainName(), GlobalParamsAction::setTripleIndexParam(), NodeSetsGeneratorBase::setup(), Split::setup(), SideSetsGeneratorBase::setup(), TransientMultiApp::setupApp(), GlobalParamsAction::setVectorParam(), FullSolveMultiApp::showStatusMessage(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< Real >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransientMultiApp::TransientMultiApp(), MooseServer::traverseParseTreeAndFillSymbols(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVFluxBC::uOnGhost(), FVFluxBC::uOnUSub(), UserObject::UserObject(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

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 435 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), SetupDebugAction::act(), CommonOutputAction::act(), AddPeriodicBCAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADNodalKernel::ADNodalKernel(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelTempl< Real >::AuxKernelTempl(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), PiecewiseTabularBase::buildFromFile(), MFEMMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), checkComponent(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), FunctorAux::computeValue(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), ReporterPointSource::fillPoint(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), AddMetaDataGenerator::generate(), ElementsToTetrahedronsConverter::generate(), BlockToMeshConverterGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BlockDeletionGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryElementConversionGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), BreakMeshByBlockGenerator::generate(), AdvancedExtruderGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), CombinerGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), JSONOutput::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ElementSubdomainModifierBase::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshGenerator::PolyLineMeshGenerator(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupParameterDerivativeMappings(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SymmetryTransformGenerator::SymmetryTransformGenerator(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), TimeSequenceStepperBase::updateSequence(), UserObject::UserObject(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), ParsedMaterialBase::validateVectorNames(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

parameterConsistent()

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

protectedinherited

Return whether two parameters are consistent.

Parameters

other_param	InputParameters object from another object to check the 'param_name' parameter in
param_name	the name of the parameter to check for consistency

Definition at line 460 of file InputParametersChecksUtils.h.

{
  assertParamDefined<T>(param_name);
  mooseAssert(other_param.have_parameter<T>(param_name),
              "This should have been a parameter from the parameters being compared");
  bool consistent = true;
  if (forwardParameters().isParamValid(param_name) && other_param.isParamValid(param_name))
  {
    if constexpr (std::is_same_v<MooseEnum, T>)
    {
      if (!forwardGetParam<T>(param_name).compareCurrent(other_param.get<T>(param_name)))
        consistent = false;
    }
    else if (forwardGetParam<T>(param_name) != other_param.get<T>(param_name))
      consistent = false;
  }
  return consistent;
}

parameters()

const InputParameters& MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 127 of file MooseBase.h.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), SetupDebugAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), MFEMProblem::addAuxVariable(), DisplacedProblem::addAuxVariable(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFunction(), FEProblemBase::addFunction(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), MFEMProblem::addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), MFEMProblem::addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMPreconditioner(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), MFEMProblem::addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), MFEMProblem::addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelTempl< Real >::AuxKernelTempl(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), 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(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), 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(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MFEMCGSolver::MFEMCGSolver(), MFEMGMRESSolver::MFEMGMRESSolver(), MFEMHypreADS::MFEMHypreADS(), MFEMHypreAMS::MFEMHypreAMS(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMHypreFGMRES::MFEMHypreFGMRES(), MFEMHypreGMRES::MFEMHypreGMRES(), MFEMHyprePCG::MFEMHyprePCG(), MFEMOperatorJacobiSmoother::MFEMOperatorJacobiSmoother(), MFEMSuperLU::MFEMSuperLU(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MooseServer::parseDocumentForDiagnostics(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblem::setInputParametersFEProblem(), FEProblemBase::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(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), and MooseApp::~MooseApp().

{ return _pars; }

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 449 of file MooseBase.h.

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

{
  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
}

paramWarning()

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 442 of file MooseBase.h.

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

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

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

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

{
  return _pg_moose_app.perfGraph();
}

prefix()

std::string PhysicsBase::prefix ( ) const

inlineprotectedinherited

Use prefix() to disambiguate names.

Definition at line 135 of file PhysicsBase.h.

Referenced by DiffusionCG::addBoundaryConditionsFromComponents(), DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), DiffusionPhysicsBase::addInitialConditionsFromComponents(), and DiffusionPhysicsBase::addPostprocessors().

{ return name() + "_"; }

prepareCopyVariablesFromMesh()

void PhysicsBase::prepareCopyVariablesFromMesh ( ) const

protectedinherited

Tell the app if we want to use Exodus restart.

Definition at line 223 of file PhysicsBase.C.

Referenced by PhysicsBase::PhysicsBase().

{
  if (getParam<bool>("initialize_variables_from_mesh_file"))
    _app.setExodusFileRestart(true);

  checkSecondParamSetOnlyIfFirstOneTrue("initialize_variables_from_mesh_file",
                                        "initial_from_file_timestep");
}

queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

If the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns

A pointer to the parameter value, if it exists

Definition at line 391 of file MooseBase.h.

{
  return isParamValid(name) ? &getParam<T>(name) : nullptr;
}

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_name	The name of the code section to be timed
level	The 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 53 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

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_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 64 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

reportPotentiallyMissedParameters()

void PhysicsBase::reportPotentiallyMissedParameters ( const std::vector< std::string > &  param_names, const std::string &  object_type  ) const

protectedinherited

When this is called, we are knowingly not using the value of these parameters.

This routine checks whether these parameters simply have defaults or were passed by the user

Parameters

param_names

the parameters we are ignoring

Definition at line 779 of file PhysicsBase.C.

Referenced by DiffusionCG::addSolverVariables(), and DiffusionFV::addSolverVariables().

{
  std::vector<std::string> defaults_unused;
  std::vector<std::string> user_values_unused;
  for (const auto & param : param_names)
  {
    if (isParamSetByUser(param))
      user_values_unused.push_back(param);
    else if (isParamValid(param))
      defaults_unused.push_back(param);
  }
  if (defaults_unused.size() && _verbose)
    mooseInfoRepeated("Defaults for parameters '" + Moose::stringify(defaults_unused) +
                      "' for object of type '" + object_type +
                      "' were not used because the object was not created by this Physics.");
  if (user_values_unused.size())
  {
    if (_app.unusedFlagIsWarning())
      mooseWarning(
          "User-specifed values for parameters '" + Moose::stringify(user_values_unused) +
          "' for object of type '" + object_type +
          "' were not used because the corresponding object was not created by this Physics.");
    else if (_app.unusedFlagIsError())
      mooseError(
          "User-specified values for parameters '" + Moose::stringify(user_values_unused) +
          "' for object of type '" + object_type +
          "' were not used because the corresponding object was not created by this Physics.");
  }
}

saveAuxVariableName()

void PhysicsBase::saveAuxVariableName ( const VariableName &  var_name )

inlineprotectedinherited

Keep track of the name of an aux variable defined in the Physics.

Definition at line 143 of file PhysicsBase.h.

{ _aux_var_names.push_back(var_name); }

saveSolverVariableName()

void PhysicsBase::saveSolverVariableName ( const VariableName &  var_name )

inlineprotectedinherited

Keep track of the name of the solver variable defined in the Physics.

Definition at line 138 of file PhysicsBase.h.

Referenced by DiffusionPhysicsBase::DiffusionPhysicsBase().

  {
    _solver_var_names.push_back(var_name);
  }

shouldCreateIC()

bool PhysicsBase::shouldCreateIC ( const VariableName &  var_name, const std::vector< SubdomainName > &  blocks, const bool  ic_is_default_ic, const bool  error_if_already_defined  ) const

protectedinherited

Returns whether this Physics should create the variable.

Will return false if the initial condition already exists and has the necessary block restriction.

Parameters

var_name	name of the variable
blocks	block restriction to use. If empty, no block restriction
ic_is_default_ic	whether this IC is from a default parameter, and therefore should be skipped when recovering/restarting
error_if_already_defined	two ICs cannot be defined on the same subdomain, so if this is set to true, any overlap between the subdomains of two ICs for the same variable will cause an error. If set to false, the existing ICs will take priority, and this routine will return false. Setting 'error_if_already_defined' to '!ic_is_default_ic' is a good idea if it is ok to overwrite the default IC value of the Physics.

Definition at line 626 of file PhysicsBase.C.

Referenced by DiffusionPhysicsBase::addInitialConditions().

{
  // Handle recover
  if (ic_is_default_ic && (_app.isRestarting() || _app.isRecovering()))
    return false;
  // do not set initial conditions if we are loading fields from the mesh file
  if (getParam<bool>("initialize_variables_from_mesh_file"))
    return false;
  // Different type of ICs, not block restrictable
  mooseAssert(!isVariableScalar(var_name), "shouldCreateIC not implemented for scalar variables");

  // Process the desired block restriction into a set of subdomain IDs
  std::set<SubdomainName> blocks_set(blocks.begin(), blocks.end());
  const auto blocks_ids_set = getSubdomainIDs(blocks_set);

  // Check whether there are any ICs for this variable already in the problem
  std::set<SubdomainID> blocks_ids_covered;
  bool has_all_blocks;
  if (isVariableFV(var_name))
    has_all_blocks = _problem->getFVInitialConditionWarehouse().hasObjectsForVariableAndBlocks(
        var_name, blocks_ids_set, blocks_ids_covered, /*tid =*/0);
  else
    has_all_blocks = _problem->getInitialConditionWarehouse().hasObjectsForVariableAndBlocks(
        var_name, blocks_ids_set, blocks_ids_covered, /*tid =*/0);

  const bool has_some_blocks = !blocks_ids_covered.empty();
  if (!has_some_blocks)
    return true;

  if (has_all_blocks)
  {
    if (error_if_already_defined)
      mooseError("ICs for variable '" + var_name + "' have already been defined for blocks '" +
                 Moose::stringify(blocks) + "'.");
    else
      return false;
  }

  // Partial overlap between Physics is not implemented.
  mooseError("There is a partial overlap between the subdomains covered by pre-existing initial "
             "conditions (ICs), defined on blocks (ids): " +
             Moose::stringify(getSubdomainNamesAndIDs(blocks_ids_covered)) +
             "\n and a newly created IC for variable " + var_name +
             ", to be defined on blocks: " + Moose::stringify(blocks) +
             ".\nWe should be creating the Physics' IC only for non-covered blocks. This is not "
             "implemented at this time.");
}

shouldCreateTimeDerivative()

bool PhysicsBase::shouldCreateTimeDerivative ( const VariableName &  var_name, const std::vector< SubdomainName > &  blocks, const bool  error_if_already_defined  ) const

protectedinherited

Returns whether this Physics should create the variable.

Will return false if the time derivative kernel already exists and has the necessary block restriction.

Parameters

var_name	name of the variable
blocks	block restriction to use. If empty, no block restriction
error_if_already_defined	two time derivatives can be defined on the same subdomain, but it is usually not correct. So if this is set to true, any overlap between the subdomains of two time derivatives for the same variable will cause an error. If set to false, the existing time derivative will be deemed as sufficient, and this routine will return false.

Definition at line 678 of file PhysicsBase.C.

Referenced by DiffusionCG::addFEKernels(), and DiffusionFV::addFVKernels().

{
  // Follow the transient setting of the Physics
  if (!isTransient())
    return false;

  // Variable is either nonlinear (FV/FE), nodal nonlinear (field of ODEs), linear, or scalar.
  // The warehouses hosting the time kernels are different for each of these types
  // Different type of time derivatives, not block restrictable
  mooseAssert(!isVariableScalar(var_name),
              "shouldCreateTimeDerivative not implemented for scalar variables");
  mooseAssert(!_problem->hasAuxiliaryVariable(var_name),
              "Should not be called with auxiliary variables");

  // Get solver system type
  const auto var = &_problem->getVariable(0, var_name);
  const auto var_id = var->number();
  const auto sys_num = var->sys().number();
  const auto time_vector_tag =
      (sys_num < _problem->numNonlinearSystems())
          ? var->sys().timeVectorTag()
          // this is not quite correct. Many kernels can contribute to RHS time vector on paper
          : dynamic_cast<LinearSystem *>(&var->sys())->rightHandSideTimeVectorTag();

  // We just use the warehouse, it should cover every time derivative object type
  bool all_blocks_covered = true;
  std::set<SubdomainID> blocks_ids_covered;
  // we examine subdomain by subdomain, because mutiple kernels could be covering every block in
  // the 'blocks' parameter
  for (const auto & block : blocks)
  {
    std::vector<MooseObject *> time_kernels;
    if (block != "ANY_BLOCK_ID")
    {
      const auto bid = _mesh->getSubdomainID(block);
      _problem->theWarehouse()
          .query()
          .template condition<AttribSysNum>(sys_num)
          .template condition<AttribVar>(var_id)
          .template condition<AttribSubdomains>(bid)
          // we use the time tag as a proxy for time derivatives
          .template condition<AttribVectorTags>(time_vector_tag)
          .queryInto(time_kernels);
    }
    else
      _problem->theWarehouse()
          .query()
          .template condition<AttribSysNum>(sys_num)
          .template condition<AttribVar>(var_id)
          // we use the time tag as a proxy for time derivatives
          .template condition<AttribVectorTags>(time_vector_tag)
          .queryInto(time_kernels);

    if (time_kernels.size())
    {
      if (block == "ANY_BLOCK_ID")
      {
        for (const auto & time_kernel : time_kernels)
          if (const auto blk = dynamic_cast<BlockRestrictable *>(time_kernel))
            blocks_ids_covered.insert(blk->blockIDs().begin(), blk->blockIDs().end());
      }
      else
        blocks_ids_covered.insert(_mesh->getSubdomainID(block));
    }
    else
      all_blocks_covered = false;
  }

  // From the set of covered blocks, see if the blocks we needed are found
  if (all_blocks_covered)
  {
    std::set<SubdomainName> blocks_set(blocks.begin(), blocks.end());
    const auto blocks_ids = getSubdomainIDs(blocks_set);
    if (blocks_ids != blocks_ids_covered)
      all_blocks_covered = false;
  }
  const bool has_some_blocks = !blocks_ids_covered.empty();
  if (!has_some_blocks)
    return true;
  if (all_blocks_covered)
  {
    if (error_if_already_defined)
      mooseError("A time kernel for variable '" + var_name +
                 "' has already been defined on blocks '" + Moose::stringify(blocks) + "'.");
    else
      return false;
  }

  // Partial overlap between Physics is not implemented.
  mooseError("There is a partial overlap between the subdomains covered by pre-existing time "
             "derivative kernel(s), defined on blocks (ids): " +
             Moose::stringify(getSubdomainNamesAndIDs(blocks_ids_covered)) +
             "\nand a newly created time derivative kernel for variable " + var_name +
             ", to be defined on blocks: " + Moose::stringify(blocks) +
             ".\nWe should be creating the Physics' time derivative only for non-covered "
             "blocks. This is not implemented at this time.");
}

shouldCreateVariable()

bool PhysicsBase::shouldCreateVariable ( const VariableName &  var_name, const std::vector< SubdomainName > &  blocks, const bool  error_if_aux  )

protectedinherited

Returns whether this Physics should create the variable.

Will return false if the variable already exists and has the necessary block restriction.

Parameters

var_name	name of the variable
blocks	block restriction to use. If empty, no block restriction
error_if_aux	error if the variable is auxiliary

Definition at line 602 of file PhysicsBase.C.

Referenced by DiffusionCG::addSolverVariables(), and DiffusionFV::addSolverVariables().

{
  if (!variableExists(var_name, error_if_aux))
    return true;
  // check block restriction
  auto & var = _problem->getVariable(0, var_name);
  const bool not_block_restricted =
      (std::find(blocks.begin(), blocks.end(), "ANY_BLOCK_ID") != blocks.end()) ||
      allMeshBlocks(blocks);
  if (!var.blockRestricted() || (!not_block_restricted && var.hasBlocks(blocks)))
    return false;

  // This is an edge case, which might warrant a warning
  if (allMeshBlocks(var.blocks()) && not_block_restricted)
    return false;
  else
    mooseError("Variable '" + var_name + "' already exists with subdomain restriction '" +
               Moose::stringify(var.blocks()) + "' which does not include the subdomains '" +
               Moose::stringify(blocks) + "', required for this Physics.");
}

solverVariableExists()

bool PhysicsBase::solverVariableExists ( const VariableName &  var_name ) const

protectedinherited

Check whether a variable already exists and is a solver variable.

Definition at line 434 of file PhysicsBase.C.

{
  return _problem->hasSolverVariable(var_name);
}

solverVariableNames()

const std::vector<VariableName>& PhysicsBase::solverVariableNames ( ) const

inlineinherited

Return the list of solver (nonlinear + linear) variables in this physics.

Definition at line 98 of file PhysicsBase.h.

Referenced by PhysicsBase::act(), addComponent(), and PhysicsBase::initializePhysics().

{ return _solver_var_names; };

specificTaskName()

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

inlineinherited

Definition at line 103 of file Action.h.

{ return _specific_task_name; }

timedAct()

void Action::timedAct ( )

inherited

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

Definition at line 75 of file Action.C.

Referenced by ActionWarehouse::executeActionsWithAction().

{
  TIME_SECTION(_act_timer);
  act();
}

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 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

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 89 of file MooseBase.h.

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

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

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 54 of file MooseBase.C.

Referenced by FEProblemBase::addPostprocessor(), MaterialPropertyStorage::addProperty(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

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

uniqueActionName()

MooseObjectName Action::uniqueActionName ( ) const

inlineinherited

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

Definition at line 101 of file Action.h.

Referenced by NEML2Action::NEML2Action().

{ return uniqueName(); }

uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns

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

Definition at line 66 of file MooseBase.C.

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

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

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 60 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

validParams()

InputParameters PhysicsComponentInterface::validParams ( )

static

Definition at line 14 of file PhysicsComponentInterface.C.

Referenced by DiffusionPhysicsBase::validParams().

{
  InputParameters params = PhysicsBase::validParams();
  // we likely do not need all these parameters. But developers could expect them
  return params;
}

variableExists()

bool PhysicsBase::variableExists ( const VariableName &  var_name, bool  error_if_aux  ) const

protectedinherited

Check whether a variable already exists.

Definition at line 421 of file PhysicsBase.C.

Referenced by PhysicsBase::shouldCreateVariable().

{
  if (error_if_aux && _problem->getAuxiliarySystem().hasVariable(var_name))
    mooseError("Variable '",
               var_name,
               "' is supposed to be nonlinear for physics '",
               name(),
               "' but it is already defined as auxiliary");
  else
    return _problem->hasVariable(var_name);
}

warnInconsistent()

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

protectedinherited

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

Parameters

other_param	InputParameters object from another object to check the 'param_name' parameter in
param_name	the name of the parameter to check for consistency

Definition at line 549 of file InputParametersChecksUtils.h.

{
  const bool consistent = parameterConsistent<T>(other_param, param_name);
  if (!consistent)
    forwardMooseWarning("Parameter " + param_name + " is inconsistent between Physics \"" +
                        forwardName() + "\" of type \"" + forwardType() +
                        "\" and the parameter set for \"" + other_param.getObjectName() +
                        "\" of type \"" + other_param.getObjectType() + "\"");
}

Member Data Documentation

_act_timer

PerfID Action::_act_timer

protectedinherited

Timers.

Definition at line 174 of file Action.h.

Referenced by Action::timedAct().

_action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

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

_all_tasks

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

protectedinherited

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

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

Definition at line 159 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 353 of file MooseBase.h.

_awh

ActionWarehouse& Action::_awh

protectedinherited

Reference to ActionWarehouse where we store object build by actions.

Definition at line 162 of file Action.h.

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

_blocks

std::vector<SubdomainName> PhysicsBase::_blocks

protectedinherited

Keep track of the subdomains the Physics is defined on.

Definition at line 261 of file PhysicsBase.h.

Referenced by PhysicsBase::addBlocks(), PhysicsBase::addBlocksById(), PhysicsBase::addComponent(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), DiffusionFV::addSolverVariables(), DiffusionCG::addSolverVariables(), PhysicsBase::blocks(), PhysicsBase::checkBlockRestrictionIdentical(), and PhysicsBase::initializePhysics().

_components_boundary_conditions

std::map<std::string, std::map<std::pair<VariableName, BoundaryName>, std::pair<MooseFunctorName, ComponentBoundaryConditionInterface::BoundaryConditionType> > > PhysicsComponentInterface::_components_boundary_conditions

protected

Map of components to variables and boundary conditions.

Definition at line 66 of file PhysicsComponentInterface.h.

Referenced by addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), and addBoundaryConditionsFromComponents().

_components_initial_conditions

std::map<std::string, std::map<VariableName, MooseFunctorName> > PhysicsComponentInterface::_components_initial_conditions

protected

Map of components to variables and initial conditions.

Definition at line 60 of file PhysicsComponentInterface.h.

Referenced by addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), DiffusionPhysicsBase::addInitialConditionsFromComponents(), and addInitialConditionsFromComponents().

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

_current_task

const std::string& Action::_current_task

protectedinherited

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

Definition at line 165 of file Action.h.

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

_displaced_mesh

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

protectedinherited

Definition at line 168 of file Action.h.

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

_factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

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

_mesh

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

protectedinherited

Definition at line 167 of file Action.h.

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

_name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 359 of file MooseBase.h.

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

_pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 362 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), GlobalParamsAction::parameters(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), 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 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_preconditioning

const MooseEnum& PhysicsBase::_preconditioning

protectedinherited

Whether to add a default preconditioning.

The implementation of the default is defined by the derived class

Definition at line 258 of file PhysicsBase.h.

Referenced by DiffusionPhysicsBase::addPreconditioning().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 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 171 of file Action.h.

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

_registered_identifier

std::string Action::_registered_identifier

protectedinherited

Definition at line 144 of file Action.h.

Referenced by SetupMeshAction::act().

_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 152 of file Action.h.

Referenced by Action::specificTaskName().

_system_names

std::vector<SolverSystemName> PhysicsBase::_system_names

protectedinherited

System names for the system(s) owning the solver variables.

Definition at line 248 of file PhysicsBase.h.

Referenced by PhysicsBase::checkIntegrityEarly(), PhysicsBase::getSolverSystem(), and PhysicsBase::initializePhysics().

_system_numbers

std::vector<unsigned int> PhysicsBase::_system_numbers

protectedinherited

System numbers for the system(s) owning the solver variables.

Definition at line 251 of file PhysicsBase.h.

Referenced by PhysicsBase::addPetscPairsToPetscOptions(), PhysicsBase::copyVariablesFromMesh(), and PhysicsBase::initializePhysics().

_type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 356 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseBase::MooseBase(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), FEProblemBase::solverTypeString(), and MooseBase::type().

_verbose

const bool PhysicsBase::_verbose

protectedinherited

Whether to output additional information.

Definition at line 254 of file PhysicsBase.h.

Referenced by PhysicsBase::initializePhysics(), and PhysicsBase::reportPotentiallyMissedParameters().

app_param

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

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

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

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>"

staticinherited

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

Definition at line 33 of file MeshMetaDataInterface.h.

name_param

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

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

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

SYSTEM

constexpr auto MeshMetaDataInterface::SYSTEM = "MeshMetaData"

staticinherited

The system name used when initializing the Restartable interface.

Definition at line 30 of file MeshMetaDataInterface.h.

Referenced by MeshMetaDataInterface::meshPropertyName().

type_param

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

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

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

unique_action_name_param

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

staticinherited

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

Definition at line 37 of file Action.h.

Referenced by ActionFactory::create(), and 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().

---

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

• include/physics/PhysicsComponentInterface.h
• src/physics/PhysicsComponentInterface.C